LAMBDA FUNCTIONS

Lambda functions are functions that are defined within the flow of the program’s code. Often they are defined, used, and forgotten in a single statement without ever being given a name.

To define a lambda function for later use, start with the Function keyword. Add the function’s name and any parameters that it requires, followed by a single statement that evaluates to the value that the function should return.

Next include either (1) a single statement that evaluates to the value that the function should return, or (2) a function body that ends with an End Function statement.

The following code fragment shows examples of both of these styles:

Dim square_it = Function(n As Integer) n * n
Dim factorial = Function(n As Integer) As Integer
                    Dim result As Integer = 1
                    For i As Integer = 2 To n
                        result *= i
                    Next i
                    Return result
                End Function
 
Debug.WriteLine(square_it(5))
Debug.WriteLine(factorial(5))

The code first creates a lambda function named square_it that takes parameter n and returns n * n. It then creates a multiline lambda function named factorial that calculates and returns a number’s factorial. The code finishes by calling both functions and displaying their results.

Example program LambdaFunction, which is available for download on the book’s website, contains the following code fragment:

' Define a lambda function that adds two integers.
Dim plus = Function(i1 As Integer, i2 As Integer) i1 + i2
 
' Get A and B.
Dim A As Integer = Integer.Parse(txtA.Text)
Dim B As Integer = Integer.Parse(txtB.Text)
 
' Call the lambda function to calculate the result.
txtResult.Text = plus(A, B).ToString

This code starts by defining a variable named plus. This variable holds a reference to a lambda function that takes two integers as parameters and returns their sum. The code then gets input values from text boxes and calls the plus function, passing it those values. It converts the result into a string and displays it in the txtResult text box.

This example creates a variable to hold a reference to a lambda function and then invokes the function by using that variable. It could just as easily have invoked the lambda function itself while defining it.

Example program InlineFunction, which is also available for download on the book’s website, demonstrates this in the following line of code. This line defines the function and invokes it without ever saving a reference to it.

txtResult.Text =
    (Function(i1 As Integer, i2 As Integer) i1 + i2)(A, B).ToString

Because lambda functions are declared in a single line of code, they are also called inline functions. A lambda function defined inside a subroutine or function is also sometimes called a nested function.

No matter which method the program uses to define a lambda function, it could then pass the function to another routine that will later call the function. For example, suppose subroutine PerformCalculations takes as a parameter the function it should use to perform its calculations. The following code shows how a program could call subroutine PerformCalculations while passing it the previous lambda functions:

' Define the plus function.
Dim plus = Function(i1 As Integer, i2 As Integer) i1 + i2
 
' Call PerformCalculations passing it the lambda function.
PerformCalculations(plus)
 
' Call PerformCalculations passing it an inline lambda function.
PerformCalculations(Function(i1 As Integer, i2 As Integer) i1 + i2)

Inline functions were invented for use by LINQ and are most often used with LINQ. For more information about LINQ, see Chapter 20, “LINQ.”

In addition to lambda functions, you can write lambda subroutines that are similar to lambda functions except they don’t return a value.

The following code defines two named lambda subroutines. The first does all of its work on a single line whereas the second uses the multiline format. After defining the subroutines, the code invokes them to display two messages.

Dim write_msg = Sub(msg As String) Debug.WriteLine("write_msg: " & msg)
Dim show_msg = Sub(msg As String)
                   MessageBox.Show("show_msg: " & msg)
               End Sub
 
write_msg("Hi")
show_msg("Hi again")

As with lambda functions, you can build and pass a lambda subroutine into another routine as a parameter.