BLOG

class Main {

    // This method accepts a closure as last parameter
    long process(long x, long y, Closure operation) {
        return operation(x, y)
    }

    long adder(long x, long y) {
        x + y
    }

    // times returns a closure
    Closure times(int n) {
        { long x -> n * x }
    }

    static void main(String[] args)
    {
        def add = { x, y -> x + y } // add's type is Closure

        // Invoke add closure
        def result = add(10, 5)

        Main main = new Main()
        result = main.process(10, 5, add)

        // Passing closure in-line
        //result = main.process(10, 5, { x, y -> x + y }) ou
        result = main.process(10, 5) {
            x, y -> x + y
        }

        // Using Method pointer operator
        result = main.process(10, 5, main.&adder)

        // Using times method to get a new closure for triple a number
        def triple = main.times(3)
        println triple(2) // displays 6
    }
}

class Main {

    // This method accepts a lambda as last parameter
    fun process(x: Long, y: Long, operation: (Long, Long) -> Long): Long {
        return operation(x, y)
    }

    // You can also write
    //fun process(x: Long, y: Long, operation: (Long, Long) -> Long): Long = operation(x, y)

    fun adder(x: Long, y: Long): Long = x + y

    // times returns a lambda (here a closure)
    fun times(n: Int): (Long) -> Long = { n*it }

    companion object {

        @JvmStatic
        fun main(args: Array<String>) {
            // Defining add lambda
            val add = { x: Long, y: Long ->  x + y }

            // Calling lambda
            var result = add(10, 5)

            val main = Main()
            result = main.process(10, 5, add)

            // Passing lambda in-line
            result = main.process(10, 5, { x, y -> x + y })

            // Using method reference
            result = main.process(10, 5, main::adder)

            // Using times method to get a new closure for triple a number
            val triple = (main::times)(3)
            println(triple(2)) // displays 6
        }
    }
}

object Main {

    // This method accepts a closure as last parameter
    def process(x: Long, y: Long, operation: (Long, Long) => Long): Long = operation(x, y)

    def adder(x: Long, y: Long): Long = x + y

    // times returns a closure
    def times(n: Int): (Long) => Long = { n*_ }

    def main(args: Array[String]): Unit = {
        // Defining add closure
        val add = (x: Long, y: Long) => x + y

        // Calling closure
        var result = add(10, 5)

        result = this.process(10, 5, add)

        // Passing closure in-line
        result = this.process(10, 5, (x, y) => x + y)

        // Using an existing method
        result = this.process(10, 5, adder)

        // Using times method to get a new closure for triple a number
        val triple = times(3)
        println(triple(2)) // displays 6
    }
}

namespace closures_csharp
{
    class Program
    {
        delegate long Operation(long x, long y);

        // This method accepts a delegate as last parameter
        long process(long x, long y, Operation operation)
        {
            return operation(x, y);
        }

        long adder(long x, long y)
        {
            return x + y;
        }

        // Returns a lambda (a closure here)
        Func<long, long> times(int n)
        {
            return (x) => n*x;
        }

        static void Main(string[] args)
        {
            // Using a lambda expression
            Operation add = (x, y) => x + y;

            // Invoke delegate
            var result = add(10, 5);

            var program = new Program();

            // Passing add to process method
            result = program.process(10, 5, add);

            // Using a lambda expression directly
            result = program.process(10, 5, (x, y) => x + y);

            // Using an existing method as delegate
            result = program.process(10, 5, program.adder);

            // Using times method to get a new closure for triple a number
            var triple = program.times(3);
            Console.WriteLine(triple(2L)); // displays 6
        }
    }
}

([[Type] param1[, ...]]) {
  codeBlock;
};

// This function accepts a function as last parameter
process(int a, int b, Function operation) => operation(a, b);
// Example of operation that be passed to process call
int adder(int a, int b) => a + b;

// This function returns a Function object
// We could also write Function times(int n) => (int x) => n * x;
Function times(int n) {
  return (int x) => n * x;
}


void main() {
  // A local function definition; this can ba also written as add(int a, int b) { return a + b; }
  add(int a, int b) => a + b;

  // Call add
  assert(add(1, 2) == 3);

  // Call process using add function
  assert(process(1, 2, add) == 3);

  // Call process using an inline function
  assert(process(1, 2, (a, b) => a * b) == 2);

  // Call process using a non-local function
  assert(process(1, 2, adder) == 3);
  
  // Using times function to get a new function to triple a number        
  var triple = times(3);
  assert(triple(3) == 9);
}