<span style="font-family: Symbol;">l</span>

λ

struct op_t
{
    virtual int operator()(int a, int b) = 0;
};

struct op_add : public op_t
{
    virtual int operator()(int a, int b)
    {
        return a + b;
    }
};

void show(int a, int b, op_t & op)
{
    printf("%d\n", op(a, b));
}

int main(int argc, char* argv[])
{
    op_add add;

    show(4, 5, add);

    return 0;
}

#define square(x) pow((x), 2)

Function makePowerFn(int power)
{
   int powerFn(int base)
   {
     return pow(base, power);
   }

   return powerFn;
}

Function square = makePowerFn(2);
square(3); // возвращает 9

public interface CSDescriptor extends Serializable {
    /**
     *  @return descriptor type
     */
    String getDescriptorType();
}

public interface CSDescriptor extends Serializable {
    /**
     *  @return descriptor type
     */
    String getDescriptorType(Object param);
}

let compose f g x = f(g x) ;;
let rec iterate n f =
    if n = 0 then (function x -> x)
    else compose f (iterate (n-1) f) ;;

(* использовать можно так *)
let rec power i n =
    let i_times = ( * ) i in  (* "i_times n" равно функции "умножить на i" n раз *)
        iterate n i_times 1 ;;

power 2 8 ;; (* выдаст 256 *)

LCR>let compose f g x = f(g x) ;;
LCR>let rec iterate n f =
LCR>    if n = 0 then (function x -> x)
LCR>    else compose f (iterate (n-1) f) ;;

LCR>(* использовать можно так *)
LCR>let rec power i n =
LCR>    let i_times = ( * ) i in  (* "i_times n" равно функции "умножить на i" n раз *)
LCR>        iterate n i_times 1 ;;

LCR>power 2 8 ;; (* выдаст 256 *)

let iterate n f (* x *) =
    let rec iter m x =
        if m=0 then x
        else f (iter (m-1))
    in iter n (* x *)
    ;;

(*******************************)

let iterate n f (* x *) =
    let rec iter m x =
        if m=0 then x
        else iter (m-1) (f x)
    in iter n (* x *)
    ;;

template<class F>
class iterate_n_f
{
    int n;
    F f;
public:
    iterate_n_f(int n, F f) : n(n), f(f) {}
    template<class X> X operator()(X x) const { for(int i=0; i!=n; ++i) x = f(x); return x; }
};
// карринг сделайте сами

public static Result preved(Object[] params, public Class[] types);
public static Result medved(Object[] params, public Class[] types);

public class Result
{
    public Object[] params;
    public Class[] types;
}

let mk_index list_names =
    let rec make_enum a b = if a > b then [] else a :: (make_enum (a+1) b) in
    let list_index = (make_enum 0 ((List.length list_names) - 1)) in
    let assoc_index_name = List.combine list_names list_index in
        function name -> List.assoc name assoc_index_name ;;