C++ でカリー化関数を書いてみる(2変数限定) ref: http://qiita.com/_meki/items/742ce9788f03cee51070

curry.cpp

#include <iostream>
#include <sstream>
#include <functional>

using namespace std;

/** カリー化 f(a, b) --> f(a)(b) */
template <typename A, typename B, typename C>
function < function < C(B) >(A) > curry(function<C(A, B)>& f)
{
    return [&](A& a) -> function < C(B) > {
        return [=](B& b) -> C {
            return f(a, b);
        };
    };
}

/** アンカリー化 f(a)(b) --> f(a, b) */
template <typename A, typename B, typename C>
function< C(A, B) > uncurry(function < function < C(B) >(A) >& f)
{
    return [&](A& a, B& b) -> C {
        return f(a)(b);
    };
}

int main(int argc, char* argv[])
{
    // テスト用関数。 2つの文字列を連結する
    function< string(string, string) > func = [](string a, string b) {
    return a + b;
    };

    // 普通に使用
    cout << func("Hello, ", "World!") << endl;

    // カリー化して使用
    auto func2 = curry(func);
    cout << func2("Hello, ")("World!") << endl;

    // カリー化されたものをさらにアンカリー化して使用
    auto func3 = uncurry(func2);
    cout << func3("Hello, ", "World!") << endl;

    return 0;
}

curry.scala

/** カリー化 f(a, b) --> f(a)(b) */
def curry[A, B, C] (f: (A, B) => C) : A => (B => C) = {
    (a : A) => ( (b : B) => f(a, b) )
}

/** アンカリー化 f(a)(b) --> f(a, b) */
def uncurry[A, B, C](f : A => (B => C) ) : (A, B) => C = {
    (a : A, b : B) => f(a)(b)
}

CurryImpl.h

/** A -> (B -> C) 型の関数オブジェクト */
template <typename A, typename B, typename C>
struct CurryImpl {

    // コンストラクタでオリジナルの関数をキャプチャ
    CurryImpl(function<C(A, B)>& f) : mFunc(f) {}

    /** B -> C 型の関数オブジェクトをリターンする */
    function< C(B) > operator () (A& a) {
        return CurryImpl2(mFunc, a);
    }

    function<C(A, B)> mFunc;

    /** B -> C 型の関数オブジェクト*/
    struct CurryImpl2 {

        // コンストラクタでオリジナル関数と第一引数をキャプチャ
        CurryImpl2(function<C(A, B)>& f, A& a) : mFunc(f), mA(a) {}

        C operator () (B& b) {
            return mFunc(mA, b);
        }

        function<C(A, B)> mFunc;
        A mA;
    };
};

file3.cpp

function< C(A, B) >

file4.cpp

function < function < C(B) >(A)>

file5.cpp

template <typename A, typename B, typename C>
function < function < C(B) >(A) > curry( function< C(A, B) >& f );

file7.cpp

template <typename A, typename B, typename C>
std::function < std::function < C(B) >(A) > curry(std::function<C(A, B)>& f)
{
    return [&](A& a) -> std::function < C(B) > {
        return [=](B& b) -> C {
            return f(a, b);
        };
    };
}

file8.cpp

template <typename A, typename B, typename C>
std::function < std::function < C(B) >(A) > curry(std::function<C(A, B)>& f)
{
    return [&](A& a) -> std::function < C(B) > {
        return [&](B& b) -> C {
            return f(a, b);
        };
    };
}

出力

Hello, World!
Hello, World!
Hello, World!