Каррирование или карринг (англ. currying) в информатике — преобразование функции от пары аргументов в функцию, берущую свои аргументы по одному. Это преобразование было введено М. Шейнфинкелем и Г. Фреге и получило свое название в честь Х. Карри.

Определение

Для функции h типа h : (A × B) → C оператор каррирования Λ выполняет преобразование Λ(h) : A → (B → C). Таким образом, Λ(h) берет аргумент типа A и возвращает функцию типа B → C. С интуитивной точки зрения, каррирование функции позволяет фиксировать ее некоторый аргумент, возвращая функцию от остальных аргументов. Таким образом, Λ представляет собой функцию типа Λ : (A × B → C) → (A → (B → C)).

Декаррирование вводится как обратное преобразование.

В другом смысле, преобразование ε, противоположное каррированию, восстанавливает каррированный аргумент. Для функции k типа k : A → (B → C) оператор ε типа ε: (U → V) × U → V для произвольных a: A, U = A, V = B → C выполняет преобразование ε[k, a]: B → C. Остаётся положить k = Λ(h), и для ε: (A →(B → C)) × A → (B → C) записываем ε[Λ(h), a]: B → C и ε[k, a] = ε[Λ(h), a], что устанавливает связь между каррированой и некаррированной записью функции^[1].

На практике каррирование позволяет рассматривать функцию, которая получила один из аргументов, но не все. Оператор каррирования встроен в некоторые языки программирования, что позволяет многоместные функции приводить к каррированному представлению. Примером служат языки ML и Haskell. Все языки, поддерживающие замыкание, позволяют записывать каррированные функции.

Примеры

C++

Требует наличие библиотек Boost.

#include <boost/function.hpp>
#include <boost/lambda/lambda.hpp>
 
boost::function<int(int)> curry(int a) {
  return (a + boost::lambda::_1);
}
int a = curry(4)(5); // 9

C++11

auto curry = ([](int x){return [x](int y){return x+y;};});
int a = curry(4)(5); // 9

C# (3.0)

Func<int, Func<int, int>> curry = (x => (y => x + y));
curry(4)(5); // 9

F#

let add a b = a + b //'a -> 'a -> 'a
let addOne = add 1 //'a -> 'a
let x = addOne 10 // 11

Common Lisp

(defun curry(x)
  (lambda (y) (+ x y)))
((curry 2) 3) ; вернёт 5

Haskell

curry x = (\y -> x + y)
curry 2 3 -- вернет 5

Hope

! curry - turn a binary function into a function producing a function.
!       (Named after Haskell B. Curry)
! e.g. curry f x y = f(x, y)
dec curry : (alpha # beta -> gamma) -> alpha -> beta -> gamma;
--- curry f <= lambda x => lambda y => f(x, y);
curry (+) 1;
>> lambda y => 1 + y: num->num
(curry (+) 1) 2;
>>3: num

JavaScript

function curry(x){
    return function(y){
        return x + y;
    }
}
var a = curry(4);
a(5);   // => 9

Lisp Scheme

; определение
(define (carry x)
  (lambda (y)
    (+ x y)))
; вызов
(let ((carr (carry 4)))
  (carr 5)) ;результат 9
; или так
((carry 4) 5)

OCaml

let curry x = function y -> x + y;;   (* val curry : int -> int -> int = <fun> *)
let a = curry 4 5;;   (* - : int = 9 *)

Приведение многоместной функции к каррированному представлению выполняется автоматически, как писалось выше, так как OCaml является языком из семейства ML. Поэтому можно написать так:

let curry x y = x + y;;   (* val curry : int -> int -> int = <fun> *)
let a = curry 4;;   (* val a : int -> int = <fun> *)
a 5;;   (* - : int = 9 *)

Python

curry = lambda x: lambda y: x + y
curry(4)(5)   # => 9

Perl

sub curry
{
    my $x = shift;
    return sub { return $x + shift }
}
curry(4)->(5);  # 9

PHP

Работает начиная с PHP 5.3, в котором были добавлены замыкания.^[2]

function curry($x) {
    return function ($y) use ($x) {
               return $x + $y;
           };
}
$a = curry(5);
$b = $a(10); // 15

Ruby

curry = lambda {|x| lambda {|y| x + y}}
curry[4].call(5)   // => 9

Scala

def curry(x:Int)(y:Int) = x + y   // curry: (Int)(Int)Int
curry(4)(5)   // Int = 9

Примечания