c#語言-高階函式

蘑菇先生發表於2014-11-25
C#函式

介紹

如果說函式是程式中的基本模組，程式碼段，那高階函式就是函式的高階(級)版本，其基本定義如下：
  • 函式自身接受一個或多個函式作為輸入。
  • 函式自身能輸出一個函式，即函式生產函式。
滿足其中一個條件就可以稱為高階函式。高階函式在函數語言程式設計中大量應用，c#在3.0推出Lambda表示式後，也開始逐漸使用了。

閱讀目錄

  1. 接受函式
  2. 輸出函式
  3. Currying(科裡化)

接受函式

為了方便理解，都用了自定義。

程式碼中TakeWhileSelf 能接受一個函式，可稱為高階函式。

 //自定義委託
    public delegate TResult Function<in T, out TResult>(T arg);

    //定義擴充套件方法
    public static class ExtensionByIEnumerable
    {
        public static IEnumerable<TSource> TakeWhileSelf<TSource>(this IEnumerable<TSource> source, Function<TSource, bool> predicate)
        {
            foreach (TSource iteratorVariable0 in source)
            {
                if (!predicate(iteratorVariable0))
                {
                    break;
                }
                yield return iteratorVariable0;
            }
        }
    }
    class Program
    {
        //定義個委託

        static void Main(string[] args)
        {
            List<int> myAry = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };

            Function<int, bool> predicate = (num) => num < 4;  //定義一個函式

            IEnumerable<int> q2 = myAry.TakeWhileSelf(predicate);  //

            foreach (var item in q2)
            {
                Console.WriteLine(item);
            }
            /*
             * output:
             * 1
             * 2
             * 3
             */
        }
    }

輸出函式

 程式碼中OutPutMehtod函式輸出一個函式，供呼叫。

   var t = OutPutMehtod();  //輸出函式
            bool result = t(1);

            /*
             * output:
             * true
             */

  static Function<int, bool> OutPutMehtod()
        {
            Function<int, bool> predicate = (num) => num < 4;  //定義一個函式 

            return predicate;
        }

Currying(科裡化)

一位數理邏輯學家(Haskell Curry)推出的，連Haskell語言也是由他命名的。然後根據姓氏命名Currying這個概念了。

上面例子是一元函式f(x)=y 的例子。

那Currying如何進行的呢？ 這裡引下園子兄弟的片段。

假設有如下函式：f(x, y, z) = x / y +z. 要求f(4,2, 1)的值。

首先，用4替換f(x, y, z)中的x，得到新的函式g(y, z) = f(4, y, z) = 4 / y + z

然後，用2替換g(y, z)中的引數y，得到h(z) = g(2, z) = 4/2 + z

最後，用1替換掉h(z)中的z，得到h(1) = g(2, 1) = f(4, 2, 1) = 4/2 + 1 = 3

         很顯然，如果是一個n元函式求值，這樣的替換會發生n次，注意，這裡的每次替換都是順序發生的，這和我們在做數學時上直接將4，2，1帶入x / y + z求解不一樣。

        在這個順序執行的替換過程中，每一步代入一個引數，每一步都有新的一元函式誕生，最後形成一個巢狀的一元函式鏈。

        於是，通過Currying，我們可以對任何一個多元函式進行化簡，使之能夠進行Lambda演算。

         用C#來演繹上述Currying的例子就是：

var fun=Currying();
Console.WriteLine(fun(6)(2)(1));
/*
* output:
* 4
*/

static Function<int, Function<int, Function<int, int>>> Currying()
  {
     return x => y => z => x / y + z;
 }

 

參考 http://www.cnblogs.com/fox23/archive/2009/10/22/intro-to-Lambda-calculus-and-currying.html

相關文章