平々毎々 (Hey hey, My my)

rock and roll can never die.

月別アーカイブ: 6月 2006

WEB+DB PRESS Vol.33

Web+DB Press Vol.33
見本誌いただきました。いつもありがとうございます。

今号もあちこちで大評判ですね。有名な方達が何人も執筆者に名を連ね……。
「.NET 開発天国」も負けないように面白ネタを提供しないといけないですね。「面白」はFunnyを重視しているきらいもありますが:-p もちろんInterestingも目指さないと。

広告

NEWスーパーマリオブラザーズDS

どうにかこうにか。
mario

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

連続して束縛することを考えれば、こんな形のほうがいいかな?(修正しました)

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

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

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

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

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

        public delegate Func<T1, U> CurriedFunc<T0, T1, U>(T0 arg0);
        public delegate CurriedFunc<T1, T2, U> CurriedFunc<T0, T1, T2, U>(T0 arg0);
        //以下略
    }

続・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);
        // 以下略
    }