Functions

For defining a function, you may use similar syntax known from other languages, such as Scala:

def fib(n: Int): Int = if (n == 0 || n == 1) 1 else fib(n - 1) + fib(n - 2) 

Since fib is a recursive function, you need to explicitly annotate its return type. Parameters like n always need to be annotated with their type.

Calling functions works as you might expect:

fib(5) 

Perhaps unusual, you can also call fib using Effekt’s implementation of Uniform Function Call Syntax :

5.fib() 

Here, the receiver (before the .) is simply passed as the first argument to the function fib. If there are no additional arguments, you can also omit the parenthesis:

5.fib.show.println 

To define a type polymorphic (generic) function, like the identity function, you need to introduce a type parameter enclosed in square brackets:

def identity[A](x: A): A = x val a = identity(42) val b = identity[Int](42) 

When calling the function, you may explicitly pass a type argument for each type parameter or let type inference do its job.

There are also nested function definitions. Thus, we also could have defined fib like this:

def fibNested(n: Int): Int = { def inner(last: Int, current: Int, count: Int): Int = if (count == 1) current else inner(current, last + current, count - 1) inner(0, 1, n) } 

fibNested(5) 

Only at the top level functions can be mutually recursive.

def even(n: Int): Bool = if (n <= 0) true else odd(n - 1) def odd(n: Int): Bool = if (n <= 0) false else even(n - 1) 

7.even