87 lines
1.9 KiB
Markdown
87 lines
1.9 KiB
Markdown
# Functions
|
|
|
|
Functions are first-class citizens in ginger. The simplest anonymous function
|
|
can be created like so:
|
|
|
|
```
|
|
(. fn [x]
|
|
(: + x 1))
|
|
```
|
|
|
|
This function takes in a single number and returns that number plus one. It
|
|
could be assigned to a variable on the package using `def`, or by using the
|
|
shortcut `defn`. The following two statements are equivalent:
|
|
|
|
```
|
|
(. def incr
|
|
(. fn [x]
|
|
(: + x 1)))
|
|
|
|
(. defn incr [x]
|
|
(: + x 1))
|
|
```
|
|
|
|
## Function returns
|
|
|
|
### Single returns
|
|
|
|
A function returns whatever the last expression in its execution returned. For
|
|
example:
|
|
|
|
```
|
|
(. defn abs [x]
|
|
(. if (: >= x 0)
|
|
x
|
|
(: * -1 x)))
|
|
```
|
|
|
|
This function will return the argument `x` if it is greater than or equal to 0,
|
|
or `(* -1 x)` if it's not.
|
|
|
|
### Multiple returns
|
|
|
|
A function which wishes to return multiple arguments should return them as a
|
|
vector or list of arguments. The `let` function, which can be used to define
|
|
temporary variables in a scope, can deconstruct these multiple-returns:
|
|
|
|
```
|
|
# Returns two numbers which sum up to 10
|
|
(. defn sum-10 []
|
|
[4 6])
|
|
|
|
(. let [[foo bar] (: sum-10)
|
|
(: fmt.Println "%d + %d = 10" foo bar))
|
|
```
|
|
|
|
Functions defined within a go library which return multiple values can also be
|
|
deconstructed in a `let` statement:
|
|
|
|
```
|
|
(. let [[conn err] (: net.Dial "tcp" "localhost:80")]
|
|
# do stuff)
|
|
```
|
|
|
|
## Variadic function
|
|
|
|
Functions may take in any number of variables using the `...` syntax, similar to
|
|
how go does variadic functions. The variadic variable must be the last in the
|
|
function's argument list, and is used as a list inside of the function. A list
|
|
may also be used as the input for a variadic function, also using the `...`
|
|
syntax.
|
|
|
|
The following is an example of both defining a variadic function and both ways
|
|
of using it. `+` is a variadic function in this example:
|
|
|
|
```
|
|
(. defn avg [...x]
|
|
(/
|
|
(+ x...)
|
|
(len x)))
|
|
|
|
(: fmt.Println (avg 1 2 3 4 5))
|
|
```
|
|
|
|
## Tail-recursion
|
|
|
|
TODO
|