From fbc5cea463daf87d2ec00b64bb6a6009c7142546 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bart=C5=82omiej=20Przemys=C5=82aw=20Pluta?= Date: Wed, 1 Apr 2020 21:12:22 +0200 Subject: [PATCH] Updated Functions and methods (markdown) --- Functions-and-methods.md | 50 ++++++++++++++++++++-------------------- 1 file changed, 25 insertions(+), 25 deletions(-) diff --git a/Functions-and-methods.md b/Functions-and-methods.md index a6a8098..92d3c97 100644 --- a/Functions-and-methods.md +++ b/Functions-and-methods.md @@ -14,7 +14,7 @@ As you can see on below examples implemented functions and methods mechanism is really similar to other popular languages, like Java or Python. Examples: -``` +```php # Invoking function 'println' without any arguments println(); @@ -41,7 +41,7 @@ println(newNote1 == newNote2); # true Note, that some functions or methods don't return anything. In this case expecting any returned value can throw an exception. -``` +```php # 'println' is example function, that doesn't return anything # in this case following instruction will raise an error println(println()); # error @@ -68,7 +68,7 @@ they cannot be nested in any blocks. ### Function definition Functions can be defined with `function` keyword, like it is shown on following example: -``` +```php function multipleBy2(number) { return 2*number; } @@ -90,7 +90,7 @@ Example above takes one arbitrary argument, multiplies it by 2 and then returns Because arbitrary argument can be passed, the `multipleBy2` function can throw an error in case of trying to multiple e.g. note or string, that don't support `*` operator. In this case you can put a constraint to the argument which accepts only chosen types (using Pascal/Kotlin-like syntax): -``` +```php function multipleBy2(number: int) { return 2*number; } @@ -108,7 +108,7 @@ Function `multipleBy2` will work only with int argument now. Any attempt to invo with no-int values will cause Invocation Error related to mismatched signatures. Of course, you are still able to create functions without any arguments or mix their types: -``` +```php function noArgs() { println("Hello, I don't accept any arguments."); println("Also see that I don't return anything!"); @@ -141,7 +141,7 @@ SMNP language allows you also to declare more than one argument that functions c Accepted types can be declared using _union construction_ which consists of types separated with commas (`,`) and bounded on both sides with `<` and `>` characters. Example: -``` +```php function foo(x: , y: note, z) { # 'x' can be either string, bool, int or float # whereas 'y' can be only a note @@ -165,7 +165,7 @@ SMNP language allows you to specify what objects can be contained in lists. It can be done with construction similar to _union construction_. Accepted types are separated with commas (`,`), bounded on both sides with `<` and `>` characters and placed next to `list` keyword: -``` +```php function foo(x: list) { # 'x' can be only list of ints } @@ -182,7 +182,7 @@ foo([ 1, 2, @c ]); ``` You are still able to use multiple type as constraints: -``` +```php function foo(x: list) { # 'x' can be only list of ints and notes, nothing else } @@ -201,7 +201,7 @@ foo({ @c -> 1 }); List specifier can be empty or even be absent. In this case list can contain any available types: -``` +```php function foo(x: list<>) { # 'x' can be only a list containing arbitrary objects } @@ -224,7 +224,7 @@ foo(true); ``` Specifiers can be nested - you are able to create e.g. list of lists of lists of ints etc. -``` +```php function foo(x: list>>) { } @@ -236,7 +236,7 @@ foo([[[1, 2], [3, 4]], [[5, 6], [7, 8]], 9]); ``` Of course ambiguous arguments can include specified lists: -``` +```php function foo(x: ) { # 'x' can be int, note or list containing only ints and notes } @@ -258,7 +258,7 @@ Maps can be also specified. All rules related to specified lists are also applic The only difference is map supports **2** specifiers: first one for keys and second one for values. Example: -``` +```php function foo(x: map) { # 'x' can be only a map with strings as keys and notes as values } @@ -295,7 +295,7 @@ totally optional to pass during invocation. Syntax of optional arguments is simi to variable assignment syntax. Example: -``` +```php function foo(x = 10) { # 'x' can be of any available type. # You can override default value but you don't have to. @@ -311,7 +311,7 @@ y = foo(true); # y = true ``` All kinds of arguments mentioned so far can be optional: -``` +```php function foo(x = 1, y: int = 14, z: > = [[1, @c], [@d]]) { } @@ -334,7 +334,7 @@ foo(0, 0, [], 3); As you can see, you can have as many optional arguments as you want. Just remember, that after first declared optional argument you can't use regular arguments in the same signature anymore. -``` +```php # Correct signatures function foo(a, b, c = 0) {} function bar(a, b = "hello", c = true) {} @@ -362,7 +362,7 @@ After invocation, all matched arguments are collected into one list which is pas as vararg. Example: -``` +```php function foo(a, b, ...c) { # 'c' is a list of arguments passed after 'a' and 'b' @@ -381,7 +381,7 @@ foo(true); Same as optional arguments, vararg can work with any previously mentioned kinds of arguments (except optional arguments of course). -``` +```php function foo(a, b: note, ...c: map>) { # after two arguments you can pass any number of # maps with strings as keys and list of ints and notes as values @@ -406,7 +406,7 @@ SMNP language introduces `extend` statement which allows you to add custom methods to existing types. All you need is to precise desired type and define function which will be working as new method. In the body of declared method, the extending object is available through `this` special identifier. Following listing presents a syntax of `extend` statement: -``` +```php extend int with function multipleBy(x: int) { return this*x; } @@ -422,7 +422,7 @@ is no need to cover `function multipleBy(...) {...}` statement again. Note, that type being extended must be declared only as a simple data type or map/list with optional Examples: -``` +```php # Correct extend int with function a() {} extend list with function b() {} @@ -441,7 +441,7 @@ extend int with function k() {} Because extending statement supports list/map specifiers, you can define methods that are applicable only for list/map with specified content: -``` +```php # Extends all lists, no matter of content extend list with function foo() { println("foo()"); @@ -468,7 +468,7 @@ l3.bar(); # error! Because SMNP doesn't allow you to extend multiple types in one instruction, if you want extend for example `list` and `list` (but not `list`) you have to do it separately: -``` +```php # This won't work at all extend , list> as l with function foo() { # ... @@ -488,7 +488,7 @@ extend list as l with function foo() { In case of extending type with more than one function you can use block of methods. Example: -``` +```php extend int { function multipleBy2() { return 2*this; @@ -519,7 +519,7 @@ to declare multiple functions and methods applicable to the same objects as long Note, that potential signatures' collision is evaluated only at runtime, when method is being called. Example: -``` +```php function display(x: int) { println("int: ", x); } @@ -533,7 +533,7 @@ display(14.0); # float: 14.0 ``` However: -``` +```php function display(x) { println("any: ", x); } @@ -546,7 +546,7 @@ display(14); # any: 14 display(14.0); # error! ``` The code will end with following error: -``` +```php Function invocation error Source: /.../.../scratchpad.mus Position: line 16, column 1