# Functions

A function is basically a method, but we can use a function as a first-class value:

• we can pass it as an argument or parameter to a method or function;
• we can return it from a method or function; and
• we can give it a name using `val`.

Here's an example where we give the name `add42` to a function that adds 42 to its input.

``````val add42 = (x: Int) => x + 42
// add42: Function1[Int, Int] = repl.MdocSession\$MdocApp\$\$Lambda\$13883/0x0000000103a92040@35b5b6a1``````

We can call it just like we'd call a method.

``````add42(0)
// res0: Int = 42``````

This is an example of a function literal. Let's learn about them now.

### Function Literals

We've just seen an example of a function literal, which was

``````(x: Int) => x + 42
// res1: Function1[Int, Int] = repl.MdocSession\$MdocApp\$\$Lambda\$13884/0x0000000103a76040@2e921698``````

The general syntax is an extension of this.

<div class="callout callout-info">

#### Function Literal Syntax {-}

The syntax for declaring a function literal is

``(parameter: type, ...) => expression``

where - the optional `parameter`s are the names given to the function parameters; - the `type`s are the types of the function parameters; and - the `expression` determines the result of the function.

The parentheses around the parameters are optional if the function has just a single parameter. </div>

### Function Types

To pass functions to methods we need to know how to write down their types (because when we declare a parameter we have to declare its type).

We write a function type like `(A, B) => C` where `A` and `B` are the types of the parameters and `C` is the result type. The same pattern generalises from functions of no arguments to an arbitrary number of arguments.

Here's an example. We create a method that accepts a function, and that function is from `Int` to `Int`. We write this type as `Int => Int` or `(Int) => Int`.

``````def squareF(x: Int, f: Int => Int): Int =
f(x) * f(x)``````

We can pass `add42` to this method

``````squareF(0, add42)
// res2: Int = 1764``````

We could also pass a function literal

``````squareF(0, x => x + 42)
// res3: Int = 1764``````

Note that we didn't have to put the parameter type on the function literal in this case because Scala has enough information to infer the type.

<div class="callout callout-info">

#### Function Type Declaration Syntax {-}

To declare a function type, write

``(A, B, ...) => C``

where

• `A, B, ...` are the types of the input parameters; and
• `C` is the type of the result.

If a function only has one parameter the parentheses may be dropped:

``A => B``

</div>

### Functions as Objects

All first class values are objects in Scala, including functions. This means functions can have methods, including some useful means for composition.

``````val addTen = (a: Int) => a + 10
// addTen: Function1[Int, Int] = repl.MdocSession\$MdocApp\$\$Lambda\$13886/0x0000000103a90840@1b29e778
val double = (a: Int) => a * 2
// double: Function1[Int, Int] = repl.MdocSession\$MdocApp\$\$Lambda\$13887/0x0000000103a88040@72e8ce3
val combined = addTen.andThen(double) // this composes the two functions
// combined: Function1[Int, Int] = scala.Function1\$\$Lambda\$13817/0x0000000103a70040@1f362219 // this composes the two functions
combined(5)
// res4: Int = 30``````

Calling a function is actually calling the method called `apply` on the function. Scala allows a shortcut for any object that has a method called `apply`, where can drop the method name `apply` and write the call like a function call. This means the following are equivalent.

``````val halve = (a: Int) => a / 2
// halve: Function1[Int, Int] = repl.MdocSession\$MdocApp\$\$Lambda\$13888/0x0000000103a8f040@21aec1b1
halve(4)
// res5: Int = 2
halve.apply(4)
// res6: Int = 2``````

### Converting Methods to Functions

Methods are very similar to functions, so Scala provides a way to convert functions to methods. If we follow a method name with a `_` it will be converted to a function.

``````def times42(x: Int): Int =
x * 42

val times42Function = times42 _
// times42Function: Function1[Int, Int] = repl.MdocSession\$MdocApp\$\$Lambda\$13889/0x0000000103a9f040@7568f0db``````

We can also write a method call but replace all parameters with `_` and Scala will convert the method to a function.

``````val times42Function2 = times42(_)
// times42Function2: Function1[Int, Int] = repl.MdocSession\$MdocApp\$\$Lambda\$13890/0x0000000103a9e840@6d23301``````

#### Exercises {-}

##### Function Literals

Let's get some practice writing function literals. Write a function literal that:

• squares it's `Int` input;
• has a `Color` parameter and spins the hue of that `Color` by 15 degrees; and
• takes an `Image` input and creates four copies in a row, where each copy is rotated by 90 degrees relative to the previous image (use the `rotate` method on `Image` to achieve this.)

<div class="solution"> The first function is

``````(x: Int) => x * x
// res7: Function1[Int, Int] = repl.MdocSession\$MdocApp\$\$Lambda\$13891/0x0000000103a9d840@28daff28``````

The second is

``````(c: Color) => c.spin(15.degrees)
// res8: Function1[Color, HSLA] = repl.MdocSession\$MdocApp\$\$Lambda\$13892/0x0000000103a8e840@7f2e10cb``````

The third is

``````(image: Image) =>
image.beside(image.rotate(90.degrees))
.beside(image.rotate(180.degrees))
.beside(image.rotate(270.degrees))
.beside(image.rotate(360.degrees))
// res9: Function1[Image, Image] = repl.MdocSession\$MdocApp\$\$Lambda\$13893/0x0000000103a8d840@4d72d9dd``````

</div>

##### Function Types {-}

Here's an interesting function we'll do more with in later sections. We don't need to understand what it does right now, though you might want to experiment with it.

``````val roseFn = (angle: Angle) =>
Point.cartesian((angle * 7).cos * angle.cos, (angle * 7).cos * angle.sin)``````

What is the type of the function `roseFn` defined above? What does this type mean?

<div class="solution"> The type is `Angle => Point`. This means `roseFn` is a function that takes a single argument of type `Angle` and returns a value of type `Point`. In other words, `roseFn` transforms an `Angle` to a `Point`. </div>

Paths→