OCaml:

let rec flip f b a = f a b

Haskell:

flip f b a = f a b

Nemerle:

def flip (f,b,a)
    f(a,b)

Scheme:

// тут не уверен ;)
(define (flip f b a) (f a b))

// ну и попробую пожалуй
Erlang:

flip( f, b, a ) -> f( a, b )

let digit_p =
  item_p >>= function
        '0' -> return 0
      | '1' -> return 1
      | '2' -> return 2
      | '3' -> return 3
      | '4' -> return 4
      | '5' -> return 5
      | '6' -> return 6
      | '7' -> return 7
      | '8' -> return 8
      | '9' -> return 9
      | _   -> fail

let unsigned_p =
  one_or_more digit_p >>= fun digits ->
  return (List.fold_left (fun x y -> x*10 + y) 0 digits)

let sign_p =
  item_p >>= function
      '+' -> return 1
    | '-' -> return (-1)
    | _   -> fail

let opt_sign_p = optional sign_p 1

let integer_p =
  opt_sign_p  >>= fun sign ->
  unsigned_p  >>= fun x    ->
  return (sign * x)

let fractional_part_p =
  literal_p '.' >>
  unsigned_p    >>= fun f ->
  return f

let real_p =
  opt_sign_p                   >>= fun sign ->
  unsigned_p                   >>= fun i    ->
  optional fractional_part_p 0 >>= fun f ->
  return (make_real sign i f)

curry(Fun, Arity) ->
    curry(Fun, Arity, []).

curry(Fun, 0, Args) ->
    apply(Fun, lists:reverse(Args));
curry(Fun, Arity, Args) ->
    fun (Arg) -> curry(Fun, Arity - 1, [Arg | Args]) end.

test() ->
    F0 = curry(fun (A, B, C, D) -> {A, B, C, D} end, 4),
    F1 = F0(1),
    F2 = F1(2),
    F3 = F2(3),
    {1, 2, 3, 4} = F3(4).

PA>каррингом от языков без .

middle f a c = \b -> f a b c
middle f 1 2

ie>Ща попробую, как тут обычно делают

J:

flip =: ~

x f~ y = y f x
f~ y   = y f y
Например:
  +~ 10
20

ie>Scheme:

ie>// тут не уверен ;)
ie>(define (flip f b a) (f a b))

(define (flip f) (lambda (a b) (f b a)))

  let fib n = 1;;
у нас определена функция fib
теперь мы её переопределяем
  let fib n = if n < 2 then 1 else fib(n-1) + fib(n-2);;
здесь ссылки на старое определение -^----------^
ещё раз переопределяем
  let rec fib n = if n < 2 then 1 else fib(n-1) + fib(n-2);;
а здесь те же ссылки уже на вновь определямое значение

[1..10].Map(_ * 2)

L>(define (flip f) (lambda (a b) (f b a)))
L>

(define (flip f) (lambda (a) (lambda ( b) (f b a))))

L>let rec f x = g x
L>    and g x = f x;;

let x = .....
let y = .....
let z = .....
.....

let x = ( ..... )
in
    let y = ( ..... )
    in
        let z = ( ..... )
        in
            ( ..... )
    end
end

x = ... y ... z ... -- это глобальные имена

y = -- всё что ниже и оттабулировано - это вложенная область видимости
    ... x ... -- поэтому компилятор видит локальный x (а человек понимает, что искать x надо сперва в блоке where, и только потом вовне)
    where
        x = .....

z = ... x ... y ... -- это глобальные имена

Вывод типов в системе с каррингом слегка удобнее.

>:t (/2)
flip (/) 2 :: Fractional a => a -> a

поскипал

number = do
    s <- many1 digit
    return (read s)

expr = simpleExpr <|> addExpr

simpleExpr = number <|> paren

paren = do
    char '('
    x <- expr
    char ')'
    return x

и т.д.

L>number = do
L>    s <- many1 digit
L>    return (read s)

L>expr = simpleExpr <|> addExpr

L>simpleExpr = number <|> paren

L>paren = do
L>    char '('
L>    x <- expr
L>    char ')'
L>    return x
L>и т.д.
L>

% в прологе ; это |
expr(E) --> simpleExpr(E); addExpr(E).
simpleExpr(E) --> num(E); "(", expr(E), ")".
addExpr(X + Y) --> simpleExpr(X), "+", expr(Y).

num(N) --> digit(D0), digits(D), { number_chars(N, [D0|D]) }.
digits([D|T]) --> digit(D), !, digits(T).
digits([]) --> [].
digit(D) --> [D], { code_type(D, digit) }.

num(N) --> many1(digit,Ds), { number_chars(N, Ds) }

foreach ((name, lst) when lst.Exists(_ is MethodBuilder) in _extension_methods.KeyValuePairs)
    ...

PA>rec лишний

Function definitions may be recursive, provided this is requested explicitly, using the keyword rec:
let rec fib n = if n < 2 then 1 else fib(n-1) + fib(n-2);;

# let fib n = 1;;
val fib : 'a -> int = <fun>
# fib 8;;
- : int = 1
# let fib n = if n < 2 then 1 else fib(n-1) + fib(n-2);;
val fib : 'a -> int = <fun>
# fib 8;;
- : int = 2
# let rec fib n = if n < 2 then 1 else fib(n-1) + fib(n-2);;
val fib : int -> int = <fun>
# fib 8;;
- : int = 34

let rec f x = g x
    and g x = f x;;