Janmejani Software Consultant

Knoldus Software LLP

Functions In Scala

AGENDA● What is Functions.

● Local Functions.

● First Class Function

● Placeholders

● Partially Applied Functions

● Closures

● Repeated Parameters

● Tail Recursion

What is Function

➢ A function is a group of statements that together perform a task.

➢ When program gets larger, you need some way to divide them into smaller more manageable pieces.

➢ How you divide is up to you, but logically each function perform a specific task.

Difference Between Functions And Methods

Functions➢ Functions have independent

existence means they can be defined outside of the class.

➢ Functions are called independently.

Methods➢ Methods do not have

independent existence they are always defined with in class.

➢ Methods are called using instance or object.

Functions Declaration And Definition

def functionName ([list of parameters]) : [return type]

def functionName ([list of parameters]) : [return type] = { function body return [expr] }

def addInt( a:Int, b:Int ) = { var sum = 0 sum = a + b sum }

Calling Functions

Following is the standard way to call a method:

object Test { def main(args: Array[String]) { println( "Returned Value : " + addInt(5,7) ) }

def addInt( a:Int, b:Int ) : a+b}

Local Functions

Scala allows you to define functions inside a function are called local functions.

def factorial(i: Int): Int = { def fact(i: Int, factor: Int): Int = { if (i <= 1) factor else fact(i - 1, i * factor) } fact(i, 1) }}

First Class Functions

Scala supports first-class functions,which means you can express functions in function literal syntax, ie. , (x: Int) => x + 1,

A function literal is compiled into a class that when instantiated at run-time is a function value. For eg :

var increase = (x: Int) => x + 1

increase(10)

Functions Applied On Functions

foreach:

It takes a function as an argument and invokes that function on each of its elements.

For eg: val someNumbers = List(-11, -10, -5, 0, 5, 10)

SomeNumbers foreach((x: Int) => println(x))

Filters:

Scala provides a number of ways to leave out redundant information.

This method selects those elements of a collection that pass a test the user supplies.

For eg:someNumbers.filter(x => x > 0)

someNumbers.filter(_> 0)

To make a function literal even more concise, you can use underscores as placeholders for one or more parameters, so long as each parameter appears only one time within the function literal.

Partially Applied Functions

Replace the entire list of parameter. For example, rather than writing println(_), you could write println _.

val someNumbers = List(-11, -10, -5, 0, 5, 10)

someNumbers.foreach(println _)

A partially applied function is an expression in which you don’t supply all of the arguments needed by the function. Instead, you supply some, or none, of the needed arguments.

Closures

A closure is a function whose return value depends on the value of one or more variables declared outside this function. For eg:

val multiplier = (i:Int) => i * 10➢ A statement with no free variable is called close term.

val multiplier = (i:Int) => i * factor➢ A statement with free variable is called open term.

factor is a free variablei is a bound variable

The function value (the object) that’s created at runtime from this function literal is called a closure.

REPEATED PARAMETERS

Scala allows you to indicate that the last parameter to a function may be Repeated.

This allows clients to pass variable length argument lists to the Function.

For eg: def Size(is: Int*) = is.length

println(Size(2,3,4,5,6,67))

To denote a repeated parameter, place an asterisk after the type of the parameter.

Tail Recursion

In order for a recursive call to be tail recursive, the call back to the function must be the last action performed in the function.

def factorial(number:Int) : Int = { if (number == 1) return 1 number * factorial (number - 1)

}println(factorial(5))

This is not a tail recursive Function, because the total returned from the recursive call is being multiplied by number, the recursive call is NOT the last action performed in the function.

To take this example and make it tail recursive, we must make sure that last

action performed in the function is the recursive call.

def factorial(fact: Int, number: Int) : Int = { if(number == 1) return fact factorial(number * fact, number - 1)}print(factorial(1,5))

Why Tail Recursion?

In the recursion example, notice how the result of each call must be remembered, to do this each recursive call requires an entry on the stack until all recursive calls have been made. This makes the recursive call more expensive in terms of memory.

While in the tail recursive example, there are no intermediate values that need to be stored on the stack, the intermediate value is always passed back as a parameter.