In this tutorial, we will discuss some Scala Functions. Moreover, we will study how to define and declare functions in Scala. Along with this, we will learn how to call your own Scala function. At last, we will cover different types of Scala Functions.<\/p>\n
So, let’s start the Scala Function Tutorial.<\/p>\n
When we want to execute a group of statements to perform a task a hundred times, we don\u2019t type them a hundred times. We group them into a function, put a call to that function inside a loop, and make that loop run a hundred times.<\/p>\n
Well, dividing our code into functions also makes for modularity – it makes it easier to debug and modify the code. We can do this division according to the tasks we carry out in our code.<\/p>\n
Scala is rich with built-in functions, and it also lets us create our own. Here, Scala function is first-class value.<\/p>\n
Scala also has methods, but these differ only slightly from Scala function. A method belongs to a class; it has a name, a signature, [optionally, ] some annotations, and some bytecode. A function is a complete object that we can store in a variable. Then, a method is a function that is a member of some object. You can also learn Scala Variable <\/a>and Other Scala tutorials from our blog long with Scala Functions.<\/p>\n To create a Scala function, we use the keyword \u2018def\u2019.<\/p>\n Here\u2019s the syntax you\u2019ll want to follow:<\/p>\n Now here, while you must mention the types of parameters, the type of Scala function is optional. What else is optional is the \u2018=\u2019 operator. Let\u2019s see examples for each kind of declaration.<\/p>\n You can consider this to be the simplest kind of Scala function declaration.<\/p>\n Now, let\u2019s call it.<\/p>\n Hello We can declare a Scala function that takes parameters to work on to produce a result. Here, we simply print that result instead of returning it.<\/p>\n 7 With the = operator, a function takes a return type, and also returns a value of that type.<\/p>\n To break out of this, press Ctrl+D. Note that this, however, wouldn\u2019t work:<\/p>\n Let\u2019s try defining a Scala function to work on some parameters to return a result.<\/p>\n This would\u2019ve worked too:<\/p>\n This means that a function will return the value of the expression right before the closing curly brace; the \u2018return\u2019 keyword isn\u2019t necessary.<\/p>\n Learn: Scala DataTypes with Syntax and Examples<\/a><\/strong><\/p>\n A Scala function involves in recursion when it makes a call to itself. Let\u2019s take an example:<\/p>\n This Scala\u00a0 function correctly calculates the factorial of an integer one or greater. If we elide an argument in a function call, Scala will take the default value we provided for it.<\/p>\n 14 Learn: Scala String: Creating String, Concatenation, String Length<\/a><\/strong><\/p>\n When we want to pass arguments to a Scala function in a different order, we can pass them with names:<\/p>\n Learn: Scala Arrays and Multidimensional Arrays in Scala<\/a><\/strong><\/p>\n When we don\u2019t know how many arguments we\u2019ll want to pass, we can use a variable argument for this:<\/p>\n Since Scala is a highly functional language, it treats its functions as first-class citizens. This means that we can pass them around as parameters, or even return them from functions.<\/p>\n Let\u2019s first define a Scala function sayhello:<\/p>\n Now, let\u2019s define a function func that calls \u2018sayhello\u2019 on \u2018name\u2019.<\/p>\n Hello, Ayushi Learn: Tuples in Scala \u2013 A Quick Introduction<\/a><\/strong><\/p>\n With Scala, we can define a Scala function inside another. This is what a local function looks like:<\/p>\n In outer In outerDeclaring a Function in Scala<\/h3>\n
a. Syntax<\/h4>\n
def functionName(parameters:typeofparameters):returntypeoffunction={\r\n\/\/statements to be executed\r\n}<\/pre>\nb. Without = | Without Parameters<\/h4>\n
scala> def sayhello(){\r\n | println(\"Hello\")\r\n | }\r\nsayhello: ()Unit\r\n<\/pre>\nscala> sayhello()<\/pre>\n
\nAs you can see, since we make this function return nothing, it returns Unit. All that this Scala function does is take no parameters and simply print Hello.<\/p>\nc. Without = | With Parameters<\/h4>\n
scala> def sum(a:Int,b:Int)\r\n | {\r\n | println(a+b)\r\n | }\r\nsum: (a: Int, b: Int)Unit\r\nscala> sum(2,5)<\/pre>\n
\nThis code prints the sum of two integers. By default, this Scala function returns Unit.<\/p>\nd. With = | Without Parameters<\/h4>\n
scala> def func():Int={\r\n | return 7\r\n | }\r\nfunc: ()Int\r\nIn Scala, if you type in the same commands again, it will detect that:\r\nscala> scala> def func():Int={\r\n\/\/ Detected repl transcript. Paste more, or ctrl-D to finish.\r\n | return 7\r\n | }\r\nfunc: ()Int<\/pre>\n
\n\/\/ Replaying 1 commands from transcript.<\/p>\nscala> def func():Int={\r\nreturn 7\r\n}\r\nfunc: ()Int\r\nscala><\/pre>\nscala> def func()={\r\n | return 7\r\n | }\r\n<console>:15: error: method func has return statement; needs result type\r\n return 7\r\n ^<\/pre>\ne. With = | With Parameters<\/h4>\n
scala> def sum(a:Int,b:Int):Int={\r\n | return a+b\r\n | }\r\nsum: (a: Int, b: Int)Int\r\nscala> sum(2,5)\r\nres22: Int = 7<\/pre>\nscala> def sum(a:Int,b:Int):Int={\r\n | println(\"Adding\")\r\n | a+b\r\n | }\r\nsum: (a: Int, b: Int)Int\r\nscala> sum(2,5)\r\nAdding\r\nres23: Int = 7<\/pre>\nRecursion in Scala Function<\/h3>\n
scala> def factorial(n:Int):Int={\r\n | if(n==1)\r\n | {\r\n | return 1\r\n | }\r\n | n*factorial(n-1)\r\n | }\r\nfactorial: (n: Int)Int\r\nscala> factorial(6)\r\nres0: Int = 720\r\nscala> factorial(1)\r\nres1: Int = 1\r\nscala> factorial(4)\r\nres2: Int = 24\r\nscala> factorial(10)\r\nres4: Int = 3628800<\/pre>\n
\nLearn: Scala Comments with Syntax and Example<\/a><\/strong><\/p>\nDefault Arguments in Scala<\/h3>\n
scala> def func(a:Int,b:Int=7){\r\n | println(a*b)\r\n | }\r\nfunc: (a: Int, b: Int)Unit\r\nscala> func(2,5)\r\n10\r\nscala> func(2)<\/pre>\n
\nBut make sure that any default arguments must be after all non-default arguments. The following code raises an error:<\/p>\nscala> def func(a:Int=7,b:String){\r\n | println(s\"$a $b\")\r\n | }\r\nfunc: (a: Int, b: String)Unit\r\nscala> func(\"Ayushi\")\r\n<console>:13: error: not enough arguments for method func: (a: Int, b: String)Unit.\r\nUnspecified value parameter b.\r\n func(\"Ayushi\")\r\n ^<\/pre>\nScala Named Arguments<\/h3>\n
scala> def diff(a:Int,b:Int):Int={\r\n | return b-a\r\n | }\r\ndiff: (a: Int, b: Int)Int\r\nscala> diff(2,3)\r\nres12: Int = 1\r\nscala> diff(b=3,a=2)\r\nres13: Int = 1<\/pre>\nScala Functions with Variable Arguments<\/h3>\n
scala> def sum(args:Int*):Int={\r\n | var result=0\r\n | for(arg<-args){\r\n | result+=arg\r\n | }\r\n | result}\r\nsum: (args: Int*)Int\r\nLet\u2019s try calling this with different number of arguments.\r\nscala> sum(1)\r\nres0: Int = 1\r\nscala> sum(2,3)\r\nres1: Int = 5\r\nscala> sum(4,5,2,7)\r\nres2: Int = 18<\/pre>\nHigher-Order Functions in Scala<\/h3>\n
scala> def sayhello(s:String){\r\n | println(s\"Hello, $s\")\r\n | }\r\nsayhello: (s: String)Unit\r\nSuppose we have a string \u2018name\u2019:\r\nscala> val name:String=\"Ayushi\"\r\nname: String = Ayushi<\/pre>\nscala> def func(f:String=>Unit,s:String){\r\n | f(s)\r\n | }\r\nfunc: (f: String => Unit, s: String)Unit\r\nscala> func(sayhello,name)<\/pre>\n
\nIn this example, we used a Scala function as a parameter to another.<\/p>\nNested Functions in Scala<\/h3>\n
scala> def outer(){\r\n | println(\"In outer\")\r\n | def inner(){\r\n | println(\"In inner\")\r\n | }\r\n | inner()\r\n | }\r\nouter: ()Unit\r\nscala> outer()<\/pre>\n
\nIn inner
\nLet\u2019s take another example.<\/p>\nscala> def outer(a:Int){\r\n | println(\"In outer\")\r\n | def inner(){\r\n | println(a*3)\r\n | }\r\n | inner()\r\n | }\r\nouter: (a: Int)Unit\r\nNow, let\u2019s call it:\r\nscala> outer(3)<\/pre>\n
\n9<\/p>\n