In this Tutorial article, we will see how to work with Functional Programming in Scala Programming Language.<\/p>\n
According to Wikipedia<\/a>, the definition of Functional Programming is as follows.<\/p>\n In computer science, functional programming is a programming paradigm – a style of building the structure and elements of computer programs\u2014that treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data.<\/p>\n<\/blockquote>\n Pre-requisite: <\/b>The readers are expected to know the basics of Java and Scala Programming.<\/p>\n The following table shows an overview of the entire article:\n<\/p>\n The examples in this article are executed in the Command Prompt \/ Shell<\/i> with the Scala Interpreter. But they are guaranteed to work with any of the IDEs (like Eclipse – Scala IDE, IntelliJ IDEA etc.,<\/i>) through the respective plugins. The examples are executed with the Scala Version: 2.11.7 in Windows 7<\/strong>.<\/p>\n You may refer to my previous tutorial here<\/a> on how to install Scala, if you are a beginner with Scala.<\/p>\n In the world of Computer Programming, there are quite a few paradigms being used, right from Procedural to Object Oriented to Functional Programming. We will consider the Procedural and Functional Programming practices for our discussion in this article.<\/p>\n Though FP (Functional Programming) appears to be a new buzzword, it had been in the industry since many decades right from Imperative or Procedural Programming is a style in which you being a Developer or Programmer will instruct the computer with every step to perform the task solving a problem. It is more of you telling How to do<\/b> alongside what to do<\/i>.<\/p>\n Most of the high level Programming languages like C, C++ and Java followed Imperative Programming styles. The main disadvantage of this style is the way a state of the variable is changed during the execution of the program, as typically these languages preferred various different looping control structures like Moreover, the actual code involved in doing the work will be detailing every minute step of a problem being solved.<\/p>\n Let us understand the same with an example. Let us write a program in Java to find the first Odd number from a list of Integers.<\/p>\n FindFirstOddNumber.java<\/em><\/span><\/p>\n The code above is very simple. We have a list of Integers (intList) to be iterated for finding out the Odd numbers if any present. If there is one, we will print the number being found and then stop the iteration immediately so as to avoid the rest of the processing which is unnecessary.<\/p>\n Let us see the output of the above program.<\/p>\n As expected, the program first printed the input list of Integers and then printed the first odd number The main reason for having this sample program is to see the actual things happening in the program. If you see the line number 14, we have a meaningful temporary variable (flag) named These are the two changes we are doing in the small and simple program, where we are not just saying what this program should do, but we are also saying how<\/b> this program will work. This is the typical style of Functional Programming is a different style of programming where in you would just be declarative of saying ONLY<\/b> what to do<\/i> and NEVER<\/b> saying How to do<\/i>, while leaving those internals to the underlying Programming Language itself that supports this paradigm. It will be easy and trouble-free for programmers thereby having a much cleaner and concise code.<\/p>\n One of the significant advantages of such style of programming is you would never need to worry about the internal intricacies thereby leaving the trouble of maintaining the flag\/temporary variables, which would indirectly create any adverse effects that would affect the overall execution of the program elsewhere. Moreover, because there is no State Change, it offers various different advantages for effective and easy Unit Testing, Concurrent Programming etc., as they would be impacted if there is a global variable which could get changed by many different methods.<\/p>\n Languages like Let us understand the same with an example. Let us write the same program in Scala to find the first Odd number in a list of Integers.<\/p>\n FindFirstOddNumber.scala<\/em><\/span><\/p>\n Let us see the output of the above program.<\/p>\n The first step was compiling the scala program using Next, the program was executed using the However, if you look inside the main method, we did not have any of the temporary flag variable to control to the loop iteration, or a temporary variable to hold each element in a collection (list) every time when the loop is iterated. This way, we achieve the A Though the terms Let us see a sample method in Scala using the Scala The above code declared and defined a method named As you can easily infer from the name of the method, this method will print the name (which is passed an input to the function) along with “Hello” as a prefix. The function definition spawns across three lines where as you can see a vertical bar on the left side appearing from line 2 onwards, as soon as you press enter after completing the text from 1st line. The vertical bar continues to appear until you type the closing curly brace After the method definition is completed, scala REPL gives us back the short from of the method signature in one line – which is Let us write the same ‘sayHello’ as a function in Scala below.<\/p>\n Here a function literal (anonymous function – as it does not have any name) is assigned to the variable<\/b> name The Scala REPL interpreter gave us back the function signature in one line as follows. Let us try executing this function or a method in the Scala REPL. The execution is the same for both method and a function.<\/p>\n Because the function literal is assigned to a variable named ‘sayHello’ that takes a single input parameter, the execution will not be any different for each other.<\/p>\n As you can see, we had invoked the function ‘sayHello’ with different arguments and the Scala REPL gave us back the results instantly which are very much self explanatory. The prefix Now that we have a good understanding on the fundamentals of Functional Programming, let us see some of the core principles or concepts of the same, which are the essential building blocks of any language that supports the functional programming.<\/p>\n The term In Functional Programming, the immutability is the key factor with which a function is guaranteed to produce the same output for the same input, invariably how many ever times it is invoked. The reason being it does not mutate or change any of the values other than the input arguments like global state – a variable that is declared outside the routine or function which may cause some side effects.<\/p>\n\n
Table of Contents<\/h3>\n
\n
\n
\n
\n
<\/a>1. Environment<\/h2>\n
<\/a>2. Two different but major Programming Styles<\/h2>\n
Lisp<\/code>, Erlang<\/code> though it was originated from Lambda Calculus<\/code>. However in the recent past this style has been acquired in the newly evolved Programming languages like Scala, Ruby, Clojure etc.,<\/p>\n<\/a>2.1 Imperative or Procedural Programming<\/h3>\n
for<\/code>, while<\/code> and do-while<\/code> etc., and within these looping structures a temporary variable (called as a flag<\/code> or an interim variable<\/code> depending on the context) which gets changed for every iteration of a collection in a loop. This is actually called as a state change<\/b> of a variable which can be either local to a method or global to a class in which the method is defined.<\/p>\n<\/a>2.2 Imperative Programming – Sample Code<\/h3>\n
import java.util.List;\nimport java.util.ArrayList;\nimport java.util.Arrays;\n\npublic class FindFirstOddNumber\n{\n public static void main(String... args)\n {\n \/\/ Arrays.asList() will return an ArrayList from the list of numbers\n List intList = Arrays.asList(2,4,5,6,7);\n \n System.out.println(\"Input List : \" + intList);\n \n boolean found = false;\n\n for(int i : intList)\n {\n if(i%2==1)\n {\n System.out.println(\"Found the first odd number - \" + i);\n found = true;\n break;\n }\n }\n\n if(!found)\n {\n System.out.println(\"No odd number present in the list\");\n }\n }\n} \n<\/pre>\nC:\\Users\\javaPgms\\> java FindFirstOddNumber\nInput List : [2, 4, 5, 6, 7]\nFound the first odd number - 5\n<\/pre>\n
5<\/code> and exited.<\/p>\nfound<\/code> to be used for stopping the iteration. We also use the value of the same flag at the end of the program to determine whether or not an odd number was found in the input list. Likewise, we have a temporary looping variable called i<\/code> which is used inside an enhanced for loop (it is called as foreach<\/code> loop) where the value of i<\/code> is changed with the new value (element at the current index) for every iteration.<\/p>\nimperative<\/code> programming.<\/p>\n<\/a>2.2 Functional or Declarative Programming<\/h3>\n
Ruby<\/code>, Scala<\/code> supports multiple programming paradigms<\/b> like Object Oriented, Functional<\/i> etc., We will see the functional programming in Scala in this tutorial.<\/p>\n<\/a>2.4 Functional Programming – Sample Code<\/h3>\n
import scala.collection.immutable.List\n\nobject FindFirstOddNumber {\n def main(args: Array[String]): Unit = {\n var intList = List(2,4,5,6,7)\n println(intList)\n var firstOddNumber = intList.filter(x => x%2==1).head\n println(firstOddNumber)\n }\n}\n<\/pre>\nC:\\User\\scalaPgms\\> scalac FindFirstOddNumber.scala\n\nC:\\User\\scalaPgms\\> scala FindFirstOddNumber\nList(2, 4, 5, 6, 7)\n5\n<\/pre>\n
scalac<\/code> executable. Has there been any errors, it would have been printed in the console. An absence of the message while invoking the scalc<\/code> means the Scala source code was compiled successfully.<\/p>\nscala<\/code> executable. As expected, the program first printed the input list of Integers an then printed the first odd number 5<\/code> and exited, which is nothing different from the previous version of Java program.<\/p>\nimmutability<\/code> or the no state change<\/code>, thereby leaving all the internal implementation details to the Programming language, here in our case scala<\/code> itself. In essence, we did ONLY say what to do<\/i> but NOT<\/b> how to do<\/i>.<\/p>\n<\/a>3. What is a Function Vs Method<\/h2>\n
function<\/code> or a method<\/code> is an reusable piece of executable code which has a name and a list of parameters (or arguments) that it requires to do its work and a return type indicating the type of value it could return. In Scala, if a function returns nothing it is called as an Unit<\/code>, which is called as void<\/code> in other programming languages like C<\/code>, C++<\/code> and Java<\/code>.<\/p>\n\n
function<\/code> and method<\/code> can be interchangeably used in most places, there are subtle differences between both of them in Scala. You may please read this link<\/a> for the differences. The rest of the useful and relevant links are available at the References<\/a><\/b> section at the bottom. The primary difference between a function and a method is the a function literal can be assigned as a value to a variable whereas a method cannot be.<\/p>\n<\/blockquote>\nREPL<\/code> (Read-Evaluate-Print-Loop) interpreter.<\/p>\nscala> def sayHello(name: String) = {\n | \"Hello \" + name\n | }\nsayHello: (name: String)String\n<\/pre>\nsayHello<\/code> with the help of a keyword def<\/code> along with the set of paranthesis (<\/code> for opening and )<\/code> for closing. The parantheses are the demarcating points for the input arguments to the functions, which are also called as parameters<\/code>. In this sayHello<\/code> function, we had defined a single parameter called name<\/code> which is of type String<\/code> both of them separated by a semicolon (:) – both within the paranthesis. An equals (=) <\/code> sign as a reserved word (keyword) used to separate the method name with parameters from the method body (that contains the actual code to be executed), surrounded with a pair of curly braces {<\/code> and }<\/code>.<\/p>\n}<\/code> which is the logical ending of a code \/ method block. There is no need of an explicit<\/code> return statement at the end of the method as the last line of executable statement will be inferred as the return value automatically by Scala.\n
sayHello: (name:String) String<\/code><\/b>. This indicates that <\/u>a method named sayHello<\/code> defined with a single parameter of type String<\/code> and the method returns a value of type String<\/code> (which is the last line of the method – which is “Hello” prefixed with the ‘name’ input parameter).<\/i><\/p>\n<\/blockquote>\nscala> val sayHello = (name:String) => {\n | \"Hello \" + name\n | }\nsayHello: String => String = <function1>\n<\/pre>\nsayHello<\/code> with a parameter of type String<\/code>. The other difference here is we have used the symbol => (an equals sign with a right arrow key together)<\/code> to separate the function name and the body.<\/p>\n\n
sayHello: String => String = <function1><\/b><\/code> – meaning a function literal has been defined with an input parameter of type String<\/code> and a return value of type String<\/code>. It is of type <function1<\/b>><\/code> – meaning this is an instance of Scala’s one of the many implicit function objects that takes one (1) input argument.<\/b><\/i><\/p>\n<\/blockquote>\nscala> sayHello(\"Raghavan\")\nres22: String = Hello Raghavan\n\nscala> sayHello(\"Scala\")\nres23: String = Hello Scala\n\nscala> sayHello(\" \")\nres24: String = \"Hello \"\n<\/pre>\n
res22:<\/code> is the temporary variable Scala REPL stores as and when it keeps calculating expressions. It would be incremental for every expression being typed in the REPL interpreter. Like in our case, it is res22<\/code> to res24<\/code> – meaning the 22nd to 24th buffered results of evaluating expressions in the current session of Scala REPL interpreter.<\/p>\n<\/a>4. Functional Programing Concepts<\/h2>\n
<\/a>4.1. Immutability<\/h3>\n
immutability<\/code> refers to the ability to preserve the value of the variables unchanged. Mutable<\/code> means changeable<\/code> and immutable<\/code> means the opposite.<\/p>\n