Functions & closures

Scala Functions & Closures

Neelkanth Sachdeva

Consultant / Software Engineer

Knoldus Software LLP , New Delhi

neelkanthsachdeva.wordpress.com

neelkanth@knoldus.com

Methods

The most common way to define a function is
as a member of some object.Such a function is
called a Method.

/*
* Normal Functions
*/

object LongLines extends App{

def ProcessFile(fileName: String, width: Int)
{
val source = Source.fromFile(fileName)
for (line <- source.getLines)
processLine(fileName, width, line)
}

private def processLine(filename: String,
width: Int, line: String) {
if (line.length > width)
println(filename + ": " + line)
}
}

Local functions

Programs should be decomposed into many small functions that each
do a well-defined task. One problem with this approach is that all the
helper function names can pollute the program name space
In Java →
1.Defining private methods.
In Scala →
1. Defining private methods also works
+
2. You can define functions inside other functions

/*
* Defining Local Functions More Easily
*/
object LongLines extends App {

def ProcessFile(fileName: String,width: Int) {

def processLine(line: String) {
if (line.length > width)
println(fileName + ": " + line)
}

val source = Source.fromFile(fileName)
for (line <- source.getLines)
processLine(line)
}
}

First-class functions

Scala has first-class functions. Not only can you
define functions and call them, but you can write
down functions as unnamed literals and then
pass them around as values.

Function Literals

A function literal is compiled into a class that
when instantiated at runtime is a function value.
Then What is the difference ?
Thus the distinction between function literals and
values is that function literals exist in the source
code, whereas function values exist as objects at
runtime.

Example:

Simple function literal :-

(x: Int) => x + 1

The => designates that this function converts the thing on the left (any
integer x) to the thing on the right (x + 1). So, this is a function mapping
any integer x to x + 1.

Function values are objects, so

→ you can store them in variables

scala> var increase = (x: Int) => x + 1
increase: (Int) => Int = <function>

They are functions too , so

→ you can invoke them using the usual parentheses
function-call notation.

scala> increase(10)
res0: Int = 11

We've seen the nuts and bolts of function literals and function
values. Many Scala libraries give you opportunities to use
them e.g

foreach method:

scala> val someNumbers = List(-11, -10, -5, 0, 5, 10)
someNumbers: List[Int] = List(-11, -10, -5, 0, 5, 10)
scala> someNumbers.foreach((x: Int) => println(x))

filter method:

scala> someNumbers.filter((x: Int) => x > 0)

Short forms of function literals
Scala provides a number of ways to leave out redundant information and
write function literals more briefly. Keep your eyes open for these
opportunities, because they allow you to remove clutter from your code.

One way to make a function literal more brief is to leave off the parameter
types. Thus, the previous example with filter could be written like this:

scala> someNumbers.filter((x) => x > 0)
res7: List[Int] = List(5, 10)
Even leave the parentheses around x
scala> someNumbers.filter( x => x > 0)

Placeholder syntax

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.

scala> someNumbers.filter( _ > 0)

Partially applied functions

someNumbers.foreach( println _ )
Scala treats this short form exactly as if you had
written the following:
someNumbers.foreach(x => println(x))

When you use an underscore in this way, you are
writing a partially applied function.

Examples:

scala> def sum(a: Int, b: Int, c: Int) = a + b + c
sum: (Int,Int,Int)Int

scala> sum(1, 2, 3)
res0: Int = 6

scala> val a = sum _
a: (Int, Int, Int) => Int = <function>

scala> a.apply(1, 2, 3)
res1: Int = 6

scala> val b = sum(1, _: Int, 3)
b: (Int) => Int = <function>

scala> b(2)
res15: Int = 6

In this case, b.apply invoked sum(1, 2, 3).

scala> val c = sum

<console>:5: error: missing arguments for method sum...
follow this method with `_' if you want to treat it as
a partially applied function
val c = sum
ˆ

x → by contrast, is a bound variable, because it
does have a meaning in the context of the
function: it is defined as the function’s lone
parameter, an Int.

more → more is a free variable, because the
Function literal does not itself give a meaning to it.

So the closures is :

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

(x: Int) => x + 1, is called a closed term,
Thus a function value created at runtime from
this function literal is not a closure in the strictest
Sense .

(x: Int) => x + more, is an open term. Therefore,
any function value created at runtime from (x: Int) => x +
more will by definition require that a binding for its free
variable, more, be captured. The resulting function value,
which will contain a reference to the captured more variable,
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.

Functions & closures

More Related Content

What's hot

Viewers also liked

Similar to Functions & closures

More from Knoldus Inc.

Recently uploaded

Functions & closures