{"id":199,"date":"2022-01-20T10:14:45","date_gmt":"2022-01-20T10:14:45","guid":{"rendered":"https:\/\/www.kindsonthegenius.com\/scala\/?p=199"},"modified":"2022-01-20T10:14:45","modified_gmt":"2022-01-20T10:14:45","slug":"scala-functions","status":"publish","type":"post","link":"https:\/\/www.kindsonthegenius.com\/scala\/scala-functions\/","title":{"rendered":"Scala – Functions"},"content":{"rendered":"

In this lesson, you will learn how functions work and how to write and call functions in Scala.<\/p>\n

A function in Scala is a collection of statements that perform some given operation. Scala permits nested functions which means that a function can be defined inside another function. Moreover, function names in Scala can contain characters like +, &, -, \/ etc.<\/p>\n

The following is covered here:<\/p>\n

    \n
  1. Function Declaration and Definition<\/a><\/li>\n
  2. Calling a Function<\/a><\/li>\n
  3. Nested Functions<\/a><\/li>\n<\/ol>\n

     <\/p>\n

    1. Function Declaration and Definition<\/strong><\/h4>\n

    Function declaration<\/strong> specifies the name of the function and the return type. The syntax for declaring a function in Scala is given below:<\/p>\n

    def<\/span> functionName ([<\/span>parameters<\/span> list<\/span>])<\/span> :<\/span> [<\/span>return<\/span> type<\/span>]<\/span>\r\n<\/pre>\n
     <\/p>\n
    Function definition specifies everything about the function. It includes the function declaration and the function body.<\/p>\n
    <\/p>\n
    def<\/span> functionName ([<\/span>parameters<\/span> list<\/span>])<\/span> :<\/span> [<\/span>return<\/span> type<\/span>]<\/span> =<\/span> {<\/span>\r\n   statements\r\n   ....<\/span>\r\n   return<\/span> [<\/span>expr<\/span>]<\/span>\r\n}<\/span>\r\n<\/pre>\n
    Note that the “expr” in the return statement is optional. This means that a function may or may not return a value. Also note that the parameter list is optional as well.<\/p>\n
    The code below is an example of a function that takes two parameters which are numbers and returns the product of the two numbers:<\/p>\n
    <\/p>\n
    def<\/span> getProduct (<\/span>num1:<\/span> Int<\/span>,<\/span> num2:<\/span> Int<\/span>)<\/span>:<\/span> Int<\/span> =<\/span> {<\/span>\r\n  var<\/span> product:<\/span>Int<\/span> =<\/span> 0<\/span>\r\n  product =<\/span> num1 *<\/span> num2\r\n  return<\/span>  product\r\n}<\/span>\r\n<\/pre>\n
     <\/p>\n
    Unit Functions<\/strong> – These are also called Units. They are functions that does not return anything similar to void functions in Java.<\/p>\n
     <\/p>\n
    2. Calling a Function<\/strong><\/h4>\n
    Function call in Scala is similar to function call in Java. You simply specify the function name and the arguments to the function. Let’s write a program that includes a function that calculates the max of three numbers. They we call this function using three values.<\/p>\n
    object<\/span> ScalaTutorial<\/span> {<\/span>\r\n\r\n  def<\/span> findMax (<\/span>num1:<\/span> Int<\/span>,<\/span> num2:<\/span> Int<\/span>,<\/span> num3:<\/span> Int<\/span>)<\/span>:<\/span> Int<\/span> =<\/span> {<\/span>\r\n    var<\/span> max:<\/span>Int<\/span> =<\/span> num1\r\n    if<\/span> (<\/span>num2 ><\/span> num1)<\/span> {<\/span>\r\n      max =<\/span> num2\r\n    }<\/span>\r\n    else<\/span> if<\/span> (<\/span>num3 ><\/span> num1)<\/span> {<\/span>\r\n      max =<\/span> num3\r\n    }<\/span>\r\n    return<\/span>  max\r\n  }<\/span>\r\n\r\n  def<\/span> main(<\/span>args:<\/span> Array<\/span>[<\/span>String<\/span>])<\/span> {<\/span>\r\n    println(<\/span>\"The max of 5, 12, 9 is \"<\/span> +<\/span> findMax(<\/span>5<\/span>,<\/span> 12<\/span>,<\/span> 9<\/span>)<\/span> )<\/span>\r\n  }<\/span>\r\n}<\/span>\r\n<\/pre>\n
    Here we write a function called findMax()<\/strong><\/em>. This function using Conditional Statement to find the max of three numbers. Then in the main function, we call the findMax() function with three values and the max of the three numbers is returned.<\/p>\n
    Note that you can also use the max() function available in the scala.max package to achieve the same thing.<\/p>\n
     <\/p>\n
    3. Nested Functions<\/strong><\/h4>\n
    In Scala, you can actually define a function inside another function. This is called a nested function. The syntax for nested function is given below:<\/p>\n
    def<\/span> function1()<\/span>    \/\/Outer function<\/span>\r\n     def<\/span> function2(){<\/span>\r\n\t \/\/nested function body<\/span>\r\n     }<\/span>\r\n}<\/span>  \r\n<\/pre>\n
     <\/p>\n
    The program below is an example of nested functions to find the factorial of\u00a0 numbers.<\/p>\n
    object<\/span> NestedFunctionDemo<\/span> {<\/span>\r\n\r\n   def<\/span> factorial(<\/span>i:<\/span> Int<\/span>)<\/span>:<\/span> Int<\/span> =<\/span> {\r\n<\/span>\r\n      def<\/span> fact(<\/span>i:<\/span> Int<\/span>,<\/span> accumulator:<\/span> Int<\/span>)<\/span>:<\/span> Int<\/span> =<\/span> {<\/span> \/\/Nested function<\/span>\r\n         if<\/span> (<\/span>i <=<\/span> 1<\/span>)<\/span>\r\n            accumulator\r\n         else<\/span>\r\n            fact(<\/span>i -<\/span> 1<\/span>,<\/span> i *<\/span> accumulator)<\/span>\r\n      }\r\n<\/span>\r\n      fact(<\/span>i,<\/span> 1<\/span>)<\/span>\r\n   }<\/span>\r\n\r\n   def<\/span> main(<\/span>args:<\/span> Array<\/span>[<\/span>String<\/span>])<\/span> {<\/span>\r\n      println(<\/span> factorial(<\/span>1<\/span>)<\/span> )<\/span>\r\n      println(<\/span> factorial(<\/span>2<\/span>)<\/span> )<\/span>\r\n      println(<\/span> factorial(<\/span>3<\/span>)<\/span> )<\/span>\r\n   }<\/span>\r\n}<\/span>\r\n<\/pre>\n
    In the code above, we have a function fact()<\/strong><\/em> nested inside a parent function factorial()<\/strong><\/em>. The fact() takes a number and some total (accumulator) and multiplies accumulator by the given number minus 1. However, if the given number is <= 1. Total is returned, meaning that the factorial has been found. The the factorial() function takes a number\u00a0 and finds the factorial of the number by repeatedly calling the fact() function.<\/p>\n","protected":false},"excerpt":{"rendered":"
    In this lesson, you will learn how functions work and how to write and call functions in Scala. A function in Scala is a collection … <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[33],"class_list":["post-199","post","type-post","status-publish","format-standard","hentry","category-scala-programming","tag-scala-functions"],"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts\/199","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/comments?post=199"}],"version-history":[{"count":2,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts\/199\/revisions"}],"predecessor-version":[{"id":207,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts\/199\/revisions\/207"}],"wp:attachment":[{"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/media?parent=199"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/categories?post=199"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/tags?post=199"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}