Lambda Expressions

• For C++: https://www.onlinegdb.com/online_c++_compiler .
• For Ocaml: https://www.jdoodle.com/compile-ocaml-online .
• Python: https://www.tutorialspoint.com/execute_python_online.php.

    // C++
    #include <functional>
    #include <iostream>

    template <typename T>
    std::function<T(T)> do_it_three_times (std::function<T(T)> f) {
        return [f](T x) { return f(f(f(x))); };
    }

    int main() {
        std::function<int(int)> add_one = [](int x) {return x + 1; };
        std::function<int(int)> square = [](int x) {return x * x; };
        std::cout << do_it_three_times (add_one) (1);
        std::cout << std::endl;
        std::cout << do_it_three_times (square) (2);
        std::cout << std::endl;
        std::cout << do_it_three_times (do_it_three_times(add_one)) (0);
        std::cout << std::endl;
        // The following line does not work for C++,
        // because do_it_three_times is a function not an object
        // std::cout << do_it_three_times (do_it_three_times) (add_one) (0);
        std::function<std::function<int(int)>(std::function<int(int)>)>
          do_it_three_times_obj =
          [](std::function<int(int)> f) {return do_it_three_times (f); };
        std::cout << do_it_three_times (do_it_three_times_obj) (add_one) (0);
        std::cout << std::endl;
    }

    (* Ocaml *)
    let do_it_three_times f x = f (f (f x)) in
    let add_one x = x + 1 in
    let square x = x * x in
    Printf.printf "%d\n" (do_it_three_times add_one 1);
    Printf.printf "%d\n" (do_it_three_times square 2);
    Printf.printf "%d\n" (do_it_three_times (do_it_three_times add_one) 0);
    Printf.printf "%d\n" (do_it_three_times do_it_three_times add_one 0);

    # Python
    do_it_three_times = lambda f : lambda x : f (f (f (x)))
    add_one = lambda x : x + 1
    square = lambda x : x * x
    print (do_it_three_times (add_one) (1))
    print "\n"
    print (do_it_three_times (square) (2))
    print "\n"
    print (do_it_three_times (do_it_three_times (add_one)) (0))
    print "\n"
    print (do_it_three_times (do_it_three_times) (add_one) (0))
    print "\n"

Operational Semantics

• app (abs x t₁) t₂ --> t₁ [x ⟼ t₂] .

• The function part should evaluated first. In other words, if t₁ steps to t₁', then app t₁ t₂ steps to app t₁' t₂.
• When the function part is already evaluated (e.g. t₁ = abs x t₁', and t₁ = con (op_const Oplus)) and the argument part needs to be evaluated (i.e. tm_pend t₁), then the argument part will be evaluated. In other words, if tm_pend t₁ and step t₂ t₂', then step (app t₁ t₂) (app t₁ t₂').
• If both function part t₁ and argument part t₂ are evaluated, then app t₁ t₂ will be reduced to the result of function application.
• If the function part t₁ are evaluated and its argument part t₂ does not need to be evaluated, then app t₁ t₂ will be directly reduced to this function application's result.