Lambda Concepts

Lambdas

A Lambda is a block of code that can be passed as an argment to a function call. They are usually used in dynamic languages.

There are some principles, These are:

Lambda Basics
Arrow Functions
C# Lambda Expressions

Lambda Basics

In Java 7 you would have to implement an interface in order to listen for state changes. Imagine if you have a class called "StateOwner" which can register state event listeners.

This is an example of the state changing before Lambdas existed (for an event listener):


                            public class StateOwner{

 public void addStateListener(

  StateChangeListener listener){

  ...

 }

}

//You can also add an event listener
// using an anonymous interface
// implementation like this:

StateOwner stateOwner = new StateOwner();

stateOwner.addStateListener(
 new StateChangeListener(){

 public void onStateChange(State oldState, 
  State newState){

  // do something with the old 
     and new state.

 }

});

First a StateOwner instance is created. Then an anonymous implementation of the StateChangeListener interface is added as a listener on the StateOwner instance.

In Java 8 you can add an event listener using a Java lambda expression, like this:


                            StateOwner stateOwner = new StateOwner();

stateOwner.addStateListener(
 (oldState, newState) -> 
 System.out.println("State changed")
);

// This is the lambda expression:
// (oldState, newState) -> 
 System.out.println("State changed")

The lambda expression is matched against the parameter type of the addStateListener() method's parameter. If the lambda expression matches the parameter type (in this case the StateChangeListener interface), then the lambda expression is turned into a function that implements the same interface as that parameter.

Java lambda expressions can only be used where the type they are matched against is the single method interface. In the example above a lambda expression is used as a parameter where the parameter type was the StateChangeListener interface. This interface only has a single method. Thus, the lambda expression is matched successfully against that interface.

Arrow Functions

An arrow function expression is a syntactically compact alternative to a regular function expression, although without its own bindings to the this,arguments, super or new.target keywords. Arrow function expressions are ill suited as method, and they cannot be used as constructors.

Arrow Functions are used in JS and are similar to Lambda functions. Here is an example:


                            var planets = [
 'Mercury',
 'Earth',
 'Venus',
 'Jupiter',
 'Mars'
];

console.log(
planets.map(planet => planet.length));

// Expected output:
// Array [7,5,5,7,4];

As you can see above, the "=>" icon which implies planet.length to be the result planet. It is an anonymous function which returns the length of each string in the array, in an array form (since it is using the .map array function).


                            //The Syntax of a arrow function:

// basic:

(param1, param2, ..., paramN) => {statements}
(param1, param2, ..., paramN) => expression

// equivalent to: => {return expression;}

// advanced:

Parenthesize the body of function to return 
an object literal expression:

params => ({foo: bar})

There are lots of syntaxes out there for lambdas and once you practice a few times you'll get the hang of it.

Arrow functions are basically lambdas, and are usually anonymous, this helps with other things as JS is becoming more and more Object Oriented (ES6,8 for example).

C# Lambda Expressions

Another way to express Lambdas in a different language is in c# using Linq Tools.

This is an example assigning a lambda expression to an expression tree type:


                            System.Linq.Expressions.Expression<
Func<int, int>>
e = x => x * x;
Console.WriteLine(e);

// Output:
// x => (x * x);

You can also pass it directly as a method argument, like this:


                            int[] nums = {2,3,4,5};
var squaredNums = nums.Select(x => x * x);
Console.WriteLine(string.Join(" ",squareNum));
// Output:
// 4 9 16 25

When you use method-based syntax to call the Enumerable.Select method in the System.Linq.Enumerable class (as you do in LINQ to Objects and LINQ to XML) the parameter is a delegate type System.Fun<T,TResult>.

A Lambda expression is the most convenient way to create that delegate. When you vall the Queryable.Select method in the System.Linq.Queryable class (as you do in LINQ to SQL) the parameter type is an expression tree type Expression<Func<TSource,<TResult>>. Again, a lambda expression is just a very concise way to construct that expression tree. The lambdas allow the select calls to look similar although in fact the type of object created from the lambda is different.

These are the main points of how to make Lambdas in some of the aformentioned programming languages, there are other ways to make them too. Such as the double colon notation. All in all, this concept in programming really helps people to be more efficient with development which, in turns helps to make their code more abstract.

Sources: