Home
Search
Scala Def: return Unit and LambdasUse the def keyword and a Unit return type. A lambda is passed an argument to another function.
Def, functions. With def, a keyword in Scala, we define a function. We can specify a return type. And with lambda expressions, we use light, expression-based functions.
Syntax notes. We can place a def-function on a single line for a light, easy-to-read program. For more complex functions, multiple lines can be used.
Def example. Here we introduce 2 functions. We declare them in different ways. Both isImportant and isNotImportant return a Boolean.
First The isImportant function receives an Int and returns a Boolean. It returns true if the argument size is greater than or equal to 10.
Second The isNotImportant function uses a simpler syntax. Its return value (Boolean) is determined by the compiler.
Finally We invoke both functions. We print their result Booleans to the screen with println.
Scala program that uses def, functions
def isImportant(size: Int): Boolean = { // Return true if size is greater than or equal to 10. return size >= 10 } def isNotImportant(size: Int) = !isImportant(size) // Test the isImportant function. val result1 = isImportant(10) val result2 = isImportant(0) println(result1) println(result2) // Test the isNotImportant function. val result3 = isNotImportant(10) val result4 = isNotImportant(0) println(result3) println(result4)
true false false true
Lambda expressions. A lambda expression is a function that uses less syntax. It is often passed as argument, directly inline with the surrounding function call.
Map We use the map() function on the List to demonstrate lambdas. This function requires a function argument.
List
First We use the underscore variable (which is the argument passed to the lambda). We multiply that by 2 for the result.
Second We use the expanded lambda expression syntax. The arrow symbol separates arguments from the return expression.
Tip Both lambda expressions syntax forms are equivalent. The underscore is just a shortcut.
Scala program that uses lambda expressions
val codes = List(100, 200, 300) println(codes) // Multiply all elements by 2. // ... Place in a new List. val multiplied = codes map (_ * 2) println(multiplied) // Multiply all elements by 3, using a longer syntax form. val multiplied2 = codes map (x => x * 3) println(multiplied2)
List(100, 200, 300) List(200, 400, 600) List(300, 600, 900)
Function syntax. Scala supports many variations of function call syntax. We can omit periods. We can omit parentheses. And we can use curly brackets for blocks.
Lambdas These too can use an underscore or an explicit argument. A type (like Int) can also be supplied.
Scala program that shows function syntax variations
val numbers = List(10) // One-element list. // Use no periods or parentheses. numbers foreach println _ // Use curly brackets. numbers foreach { println _ } // Use periods and parentheses. numbers.foreach(println(_)) // Use expanded lambda syntax. numbers.foreach(x => println(x)) // Use type in lambda syntax. numbers.foreach((x: Int) => println(x)) // Use curly brackets. numbers.foreach({ (x: Int) => println(x) })
10 10 10 10 10 10
Unit. In Scala we use the Unit return type to indicate "no return value." This is a "void" function. The void keyword is not used.
Return An empty "return" statement can be used in a method that returns a Unit type. This means "no value."
Here The message() def prints a message to the screen based on its argument. It returns Unit—it is a void method.
Scala program that uses Unit return type
// The Unit type is used to indicate "void" or no return value. def message(value: String): Unit = { println("Message: " + value) } // Call void method. message("cat") message("bird")
Message: cat Message: bird
Default arguments. We can specify a default value for arguments. Here we use a default value of "medium" for the size String argument in printSize.
Note We can avoid passing an argument when a default value is provided. We can call printSize with 0 or 1 arguments.
Scala program that uses default argument
// Uses a default value of "medium" when no argument provided. def printSize(size: String = "medium") = println(size) // Print default size string. printSize() // Print specific strings. printSize("large") printSize("small")
medium large small
Repeated arguments. A def that receives a variable number of string arguments receives a "String*" type. Other types like "Int*" may also be used.
Note The argument type "String*" is not a list. But it can be looped over with a for-loop.
For
Scala program that uses variable-length arguments
def addAllLengths(values: String*): Int = { // Add all string lengths in the string variable argument. var total = 0 for (v <- values) { total += v.length() } return total } // Use variable arguments. val result = addAllLengths("cat", "bird") println(result)
7
Many variations. Some languages use strict rules for correct programs. Other programs will not compile. Scala is more relaxed: we can omit periods, parentheses, brackets.
A review. Many things can be thought of as functions. For example the position of the stars in the sky is computed based on a function. In Scala we describe these actions with clear syntax.
Home
© 2007-2021 sam allen.
see site info on the changelog.