def function(param1: Int, param2: String): String = {
if (param1 > 0) param2
else param2.reverse
}
def abs(x: Int) = if (x < 0) -x else x
def random = math.random()
def keywordFunctions are defined with the def keyword in Scala.
After the def keyword come the parameters, which are optional.
The random function in the above example has no parameters, but because it’s defined
with the def keyword it will be treated as a function, i.e. it will be computed or
evaluated every time it’s called.
We will see more about this when we talk about
The Uniform Access Principle.
Return type comes after a semicolon at the end. Return type is optional
because Scala compiler is able to infer the return type automatically based on the
function body. We will discuss type inference in details later.
In this example, return type is left to be inferred by compiler
for random and abs functions.
It is recommended to explicitly define the return type for public methods for better readability.
Function body comes after the = which should be read as is defined as.
It’s exactly as one would read it in mathematics f(x) = x^2.
Just as in mathematics there is no need for a return statements here. The last
statement of each code block determines the return value of that block.
If the body is just one statement there is no need for curly braces. Basically
the body of each function is always one statement, but there are two types of statements: single
and compound. A compound statement is a block of code between curly braces whose value
is determined by its last statement. This recursive definition is just like many
other languages but for brevity Scala lets you define single statements without
curly braces.
While we are at it let’s see how we can define values and variables
val i = 10
// i = 20 wont' compile due to 'reassignment to val'
var str = "Lorem"
str = "Now I point to something else"
val keyword is for defining final references. You can call them immutable
references or pointer but don’t confuse them with immutable types or
data structures. val is similar to final in Java or const in JavaScript.
In the example above, str is a non-final reference so we can change it
but the object it points to is a String which is immutable.
We will see more about this important aspect of functional programming
later when discussing semantics.