続・C# 2.0でカリー化を考えてみる。

引数をひとつずつ束縛するのに限定するなら、
いっぱいオーバーロードすれば実用上は問題ないのだった。
ただし、型推論が欲しくなる。

    class Program
    {
        static void Main(string[] args)
        {
            GenericFunctions.Func<int, double> curried1 = 
                Curry.Bind<int, int, double>(Devide, 3);
            GenericFunctions.Func<double> curried2 =
                Curry.Bind(curried1, 2);
            Console.WriteLine(curried2());
            Console.ReadLine();
        }

        public static double Devide(int x, int y)
        {
            return (double)x / (double)y;
        }
    }

    public class Curry
    {
        public static GenericFunctions.Func<U> Bind<T0, U>
        (GenericFunctions.Func<T0, U> f, T0 arg0)
        {
            return delegate()
            {
                return f(arg0);
            };
        }

        public static GenericFunctions.Func<T1, U> Bind<T0, T1, U>
        (GenericFunctions.Func<T0, T1, U> f, T0 arg0)
        {
            return delegate(T1 arg1)
            {
                return f(arg0, arg1);
            };
        }

        public static GenericFunctions.Func<T1, T2, U> Bind<T0, T1, T2, U>
        (GenericFunctions.Func<T0, T1, T2, U> f, T0 arg0)
        {
            return delegate(T1 arg1, T2 arg2)
            {
                return f(arg0, arg1, arg2);
            };
        }
        // 以下略
    }

    namespace GenericFunctions
    {
        public delegate U Func<U>();
        public delegate U Func<T0, U>(T0 arg0);
        public delegate U Func<T0, T1, U>(T0 arg0, T1 arg1);
        // 以下略
    }