{"id":208,"date":"2022-01-20T13:09:04","date_gmt":"2022-01-20T13:09:04","guid":{"rendered":"https:\/\/www.kindsonthegenius.com\/scala\/?p=208"},"modified":"2022-01-20T13:09:04","modified_gmt":"2022-01-20T13:09:04","slug":"scala-more-on-functions","status":"publish","type":"post","link":"https:\/\/www.kindsonthegenius.com\/scala\/scala-more-on-functions\/","title":{"rendered":"Scala – More on Functions"},"content":{"rendered":"

In this lesson, we would be covering function call by-value parameters.<\/p>\n

We would cover the following:<\/p>\n

    \n
  1. Function Call by Name<\/a><\/li>\n
  2. Functions With Variable Parameters<\/a><\/li>\n
  3. Functions With Default Arguments<\/a><\/li>\n
  4. Functions With Named Arguments<\/a><\/li>\n
  5. Recursive Functions<\/a><\/li>\n<\/ol>\n

     <\/p>\n

    1. Function Call by Name<\/strong><\/h4>\n

    Call-by-name allows us to pass the name of a function as parameter to another function call. This means that the function parameter is evaluated each time the calling function is executed.<\/p>\n

    In the example below, we have a function getTime that returns the current system time. Then we have another function currentTime that takes a time object as parameter.<\/p>\n

    \/\/ Program to demostrate Call by Name<\/span>\r\nobject<\/span> CallByNameDemo<\/span> {<\/span>\r\n\r\n  def<\/span> getTime()<\/span> =<\/span> {<\/span>\r\n    println(<\/span>\"Getting system time...\"<\/span>)<\/span>\r\n    System<\/span>.<\/span>nanoTime()<\/span>\r\n  }<\/span>\r\n\r\n  def<\/span> currentTime(<\/span>t:<\/span> =><\/span>Long<\/span>)<\/span> ={<\/span>\r\n    println(<\/span>\"Now in currentTime function...\"<\/span>)<\/span>\r\n    println(<\/span>\"Time parameter is \"<\/span> +<\/span> t)<\/span>\r\n  }<\/span>\r\n\r\n  def<\/span> main(<\/span>args:<\/span> Array<\/span>[<\/span>String<\/span>])<\/span> {<\/span>\r\n    currentTime(<\/span>getTime())<\/span>\r\n  }<\/span>\r\n}<\/span>\r\n<\/pre>\n
    Please try it out and see the output.<\/p>\n
    Now in currentTime function...\r\nGetting system time...\r\nTime parameter is 370723546094499\r\n<\/pre>\n
     <\/p>\n
    2. Function With Variable Parameters<\/strong><\/h4>\n
    In this kind of functions, you specify a parameter and then indicate that this parameter could be repeated number of time. For example, if a function takes 5 integer parameters, you can indicate this using Int*. An example is given below:<\/p>\n
    \/\/ Program to demostrate Repeated parameters<\/span>\r\nobject<\/span> FunctionDemo<\/span> {<\/span>\r\n\r\n  def<\/span> printNums(<\/span>nums:<\/span> Int*<\/span>)<\/span> =<\/span> {<\/span>\r\n    var<\/span> i:<\/span> Int<\/span> =<\/span> 0<\/span>;<\/span>\r\n\r\n    for<\/span> (<\/span>num <-<\/span> nums){<\/span>\r\n      println(<\/span>\"Num [\"<\/span> +<\/span> i +<\/span> \"] = \"<\/span> +<\/span> num )<\/span>\r\n      i =<\/span> i +<\/span> 1<\/span>\r\n    }<\/span>\r\n  }<\/span>\r\n\r\n  def<\/span> main(<\/span>args:<\/span> Array<\/span>[<\/span>String<\/span>])<\/span> {<\/span>\r\n    printNums(<\/span>34<\/span>,<\/span> 65<\/span>,<\/span> 5<\/span>,<\/span> 37<\/span>,<\/span> 76<\/span>)<\/span>\r\n  }<\/span>\r\n}<\/span>\r\n<\/pre>\n
     <\/p>\n
    3. Function Default Argument<\/strong><\/h4>\n
    In Scala, you can define a function and specify default arguments for the parameter. This means that when the function is called without any argument, it would evaluate using the default values specified in the function definition. An example is given below:<\/p>\n
    \/\/ Program to demonstrate Default argument<\/span>\r\nobject<\/span> DefaultArgumentDemo<\/span> {<\/span>\r\n\r\n  def<\/span> getSum(<\/span>num1:<\/span> Int<\/span> =<\/span> 10<\/span>,<\/span> num2:<\/span> Int<\/span> =<\/span> 20<\/span>)<\/span>:<\/span> Int<\/span> =<\/span> {<\/span>\r\n    var<\/span> sum:<\/span> Int<\/span> =<\/span> 0<\/span>;<\/span>\r\n    sum =<\/span> num1 +<\/span> num2\r\n    return<\/span> sum \/\/return keyword is redundant but ok<\/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>\"The sum is \"<\/span> +<\/span> getSum())<\/span>\r\n  }<\/span>\r\n}<\/span>\r\n<\/pre>\n
    So even though no argument is specified in the\u00a0 function call, the sum is calculated as 30 using default arguments.<\/p>\n
     <\/p>\n
    4. Function with Named Arguments<\/strong><\/h4>\n
    Normally, in a function call, you pass arguments to the function in the order they appear in the function definition. However, you can also pass the arguments to the functions in different order using named arguments. The program below uses named arguments for the function call<\/p>\n
    \/\/ Program to demostrate Named argument<\/span>\r\nobject<\/span> NamedArgumentDemo<\/span> {<\/span>\r\n\r\n  def<\/span> check(<\/span>a:<\/span> Int<\/span>,<\/span> b:<\/span> Int<\/span>,<\/span> c:<\/span> Int<\/span>)<\/span>:<\/span> Unit<\/span> =<\/span>  {<\/span>\r\n    println(<\/span>\"Argument 1 is \"<\/span> +<\/span> a)<\/span>\r\n    println(<\/span>\"Argument 2 is \"<\/span> +<\/span> b)<\/span>\r\n    println(<\/span>\"Argument 3 is \"<\/span> +<\/span> c)<\/span>\r\n  }<\/span>\r\n\r\n  def<\/span> main(<\/span>args:<\/span> Array<\/span>[<\/span>String<\/span>])<\/span> {<\/span>\r\n    check(<\/span>b =<\/span> 40<\/span>,<\/span> c =<\/span> 12<\/span>,<\/span> a =<\/span> 9<\/span>)<\/span>\r\n  }<\/span>\r\n}<\/span>\r\n<\/pre>\n
    If you execute this program, you will see that the output is:<\/p>\n
    Argument 1 is 9\r\nArgument 2 is 40\r\nArgument 3 is 12\r\n<\/pre>\n
    So even though the arguments were passed out of order, we still have them ordered using named arguments<\/p>\n
     <\/p>\n
    5. Recursive Functions<\/strong><\/h4>\n
    Recursion is a very important concept in programming and Scala is not an exception. Let’s write a Scala program to perform factorial using recursion. As you know, a recursive function is a function that calls itself.<\/p>\n
    \/\/ Program to demostrate Recursive Function<\/span>\r\nobject<\/span> RecursionDemo<\/span> {<\/span>\r\n\r\n  def<\/span> factorial(<\/span>num:<\/span> Int<\/span>)<\/span>:<\/span> Int<\/span> =<\/span>  {<\/span>\r\n    var<\/span> fact:<\/span> Int<\/span> =<\/span> 1<\/span>\r\n    if<\/span> (<\/span>num <=<\/span> 1<\/span>)<\/span> {<\/span>\r\n      fact =<\/span>  1<\/span>\r\n    }<\/span> else<\/span> {<\/span>\r\n      fact =<\/span> num *<\/span> factorial(<\/span>num -<\/span> 1<\/span>)<\/span>\r\n    }<\/span>\r\n    return<\/span> fact\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 of 5 is \"<\/span> +<\/span> factorial(<\/span>5<\/span>))<\/span>\r\n  }<\/span>\r\n}<\/span>\r\n<\/pre>\n
     <\/p>\n
    I recommend you ensure to enter these programs and run them to see the output. Also feel free to watch the free video tutorials for a clearer step by step explanation.<\/p>\n","protected":false},"excerpt":{"rendered":"
    In this lesson, we would be covering function call by-value parameters. We would cover the following: Function Call by Name Functions With Variable Parameters Functions … <\/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":[34],"class_list":["post-208","post","type-post","status-publish","format-standard","hentry","category-scala-programming","tag-functions"],"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts\/208","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=208"}],"version-history":[{"count":3,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts\/208\/revisions"}],"predecessor-version":[{"id":211,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts\/208\/revisions\/211"}],"wp:attachment":[{"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/media?parent=208"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/categories?post=208"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/tags?post=208"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}