Scala - Functions


Advertisements


A function is a group of statements that perform a task. You can divide up your code into separate functions. How you divide up your code among different functions is up to you, but logically, the division usually is so that each function performs a specific task.

Scala has both functions and methods and we use the terms method and function interchangeably with a minor difference. A Scala method is a part of a class which has a name, a signature, optionally some annotations, and some bytecode where as a function in Scala is a complete object which can be assigned to a variable. In other words, a function, which is defined as a member of some object, is called a method.

A function definition can appear anywhere in a source file and Scala permits nested function definitions, that is, function definitions inside other function definitions. Most important point to note is that Scala function's name can have characters like +, ++, ~, &,-, --, \, /, :, etc.

Function Declarations

A Scala function declaration has the following form −

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

Methods are implicitly declared abstract if you don’t use the equals sign and the method body.

Function Definitions

A Scala function definition has the following form −

Syntax

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

Here, return type could be any valid Scala data type and list of parameters will be a list of variables separated by comma and list of parameters and return type are optional. Very similar to Java, a return statement can be used along with an expression in case function returns a value. Following is the function which will add two integers and return their sum −

Syntax

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

A function, that does not return anything can return a Unit that is equivalent to void in Java and indicates that function does not return anything. The functions which do not return anything in Scala, they are called procedures.

Syntax

Here is the syntax −

object Hello{
   def printMe( ) : Unit = {
      println("Hello, Scala!")
   }
}

Calling Functions

Scala provides a number of syntactic variations for invoking methods. Following is the standard way to call a method −

functionName( list of parameters )

If a function is being called using an instance of the object, then we would use dot notation similar to Java as follows −

[instance.]functionName( list of parameters )

Try the following example program to define and then call the same function.

Example

object Demo {
   def main(args: Array[String]) {
      println( "Returned Value : " + addInt(5,7) );
   }
   
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b

      return sum
   }
}

Save the above program in Demo.scala. The following commands are used to compile and execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

Returned Value : 12

Scala functions are the heart of Scala programming and that's why Scala is assumed as a functional programming language. Following are few important concepts related to Scala functions which should be understood by a Scala programmer.

Functions Call-by-Name Functions with Named Arguments
Function with Variable Arguments Recursion Functions
Default Parameter Values Higher-Order Functions
Nested Functions Anonymous Functions
Partially Applied Functions Currying Functions


Advertisements