The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Anonymous Functions

Next ►
►

Introduction

Anonymous functions, also known as lambda expressions or simply lambdas, are a powerful feature in Scala that allows you to create functions without naming them. They are particularly useful for short, throwaway functions that are passed as arguments to higher-order functions.

Key Concepts

  1. Definition: An anonymous function is a function that is defined without a name.
  2. Syntax: The basic syntax for an anonymous function in Scala is (parameters) => expression.
  3. Usage: Commonly used in functional programming, especially with collections and higher-order functions like map, filter, and reduce.

Syntax and Structure

Basic Syntax

The general form of an anonymous function is:

(parameters) => expression

Examples

  1. Simple Anonymous Function:
val add = (x: Int, y: Int) => x + y
println(add(3, 4))  // Output: 7
  1. Anonymous Function with a Single Parameter:
val square = (x: Int) => x * x
println(square(5))  // Output: 25
  1. Anonymous Function with No Parameters:
val greet = () => "Hello, World!"
println(greet())  // Output: Hello, World!

Practical Examples

Using Anonymous Functions with Collections

Anonymous functions are often used with collection methods like map, filter, and reduce.

  1. Using map:
val numbers = List(1, 2, 3, 4, 5)
val doubled = numbers.map(x => x * 2)
println(doubled)  // Output: List(2, 4, 6, 8, 10)
  1. Using filter:
val numbers = List(1, 2, 3, 4, 5)
val evenNumbers = numbers.filter(x => x % 2 == 0)
println(evenNumbers)  // Output: List(2, 4)
  1. Using reduce:
val numbers = List(1, 2, 3, 4, 5)
val sum = numbers.reduce((x, y) => x + y)
println(sum)  // Output: 15

Exercises

Exercise 1: Basic Anonymous Function

Task: Create an anonymous function that takes two integers and returns their product.

val multiply = (x: Int, y: Int) => x * y
println(multiply(3, 4))  // Output: 12

Exercise 2: Anonymous Function with map

Task: Use an anonymous function with the map method to convert a list of temperatures in Celsius to Fahrenheit.

val celsius = List(0, 20, 37, 100)
val fahrenheit = celsius.map(c => c * 9/5 + 32)
println(fahrenheit)  // Output: List(32, 68, 98.6, 212)

Exercise 3: Anonymous Function with filter

Task: Use an anonymous function with the filter method to find all the odd numbers in a list.

val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val oddNumbers = numbers.filter(x => x % 2 != 0)
println(oddNumbers)  // Output: List(1, 3, 5, 7, 9)

Common Mistakes and Tips

  1. Type Inference: Scala can often infer the types of parameters in anonymous functions, so you can omit them for brevity.

    val doubled = numbers.map(x => x * 2)  // Type inference
val doubled = numbers.map((x: Int) => x * 2)  // Explicit type

  2. Single Parameter: For single-parameter functions, you can use the underscore (_) as a shorthand.

    val doubled = numbers.map(_ * 2)

  3. Readability: While anonymous functions are concise, ensure they remain readable. Overly complex anonymous functions can be hard to understand.

Conclusion

Anonymous functions are a versatile and powerful feature in Scala, enabling concise and expressive code, especially when working with collections and higher-order functions. By mastering anonymous functions, you can write more functional and elegant Scala code. In the next section, we will delve into collections and data structures, building on the concepts learned here.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved