F#学习之路(5)元组类型

     元组类型，表示一组有序数据类型的集合。F#通过支持元组类型，方便了我们定义临时数据结构，而不需要为了临时的数据专门定义一个数据类型。

     一、元组的定义：     

 

 let tuple_2=(1,2) 

 let tuple_3=("F#",1.9,"F# Function Language") 

   

     在F#中元组使用小括号，元素之间逗号分隔来定义。元组元素可以是任何类型。

     上面代码中，tuple_2的类型是int*int，而tuple_3的类型为string*float*string。元组类型使用元组元素类型乘号连接的方式。

   

     元组类型可以作为函数的输入参数，也可以作为函数的返回值。    

 

let test (a,b,c) = 
    a+1,b+2,c+3 

 

     上面函数的类型为 int*int*int->int*int*int

   

     元组类型虽然方便我们组织一组数据类型，而无需专门定义一个数据结构。但很显然他不能很好地帮助我们理解数据结构的语义，尤其是互操作时作为函数返回值的情况下。给元组类型取一个别名，能够部分缓解这个问题。

 

type FSharpDesc=string*float*string 

let getFSharpDesc ():FSharpDesc =
    ("F#",1.9,"F# Function Language") 

   

     二、元组类型的比较    

     在F#中元组类型可以进行比较，前提当然是同类型的元组类型。所谓同类型，是指元组的元素长度相等，元素类型相同。F#从前至后依次比较。    

 

do printfn "%b" ((1,2,3,4,5,6,7,8,9) <(2,1,2,3,4,5,6,7,8)) 

   

     打印的结果 为 true    

   

     三、元组与模式匹配 

      模式匹配在函数式语言中经常出现，其功能强大。比命令式语言中switch强大的多。不仅可以匹配基本类型、元组类型、列表类型、记录类型，还可以用于类型检测。在F#中还允许自定义类型的模式匹配，通过活动模式(Active Pattern)可以做到这一点。

     

let tuple_7=(1,2,3,4,5,6,(7,8,9)) 

let one,two,three,four,five,six,seven=tuple_7    

[one;two;three;four;five;six;] @ (match seven with t1,t2,t3 ->[t1;t2;t3] ) 
|> List.iteri 
   (fun index item ->printfn "%d,%A" index item) 

 

    元组类型不仅可以使用常用的模式匹配方法。 

   

 match seven with t1,t2,t3 ->[t1;t2;t3] 

    

     还可以使用隐式的模式匹配方法来分解元组

    

let one,two,three,four,five,six,seven=tuple_7

       

    这种隐式的模式匹配大大方便了我们使用元组类型的分解。上面的代码使用了列表，列表将在下一篇博客中讨论。

 

     四、元组类型的互操作

     在学习F#函数时，我们知道F#函数的输入参数是不需要括号的。

     

let f1 a b c =
  a+b+c

let f2 (a,b,c) =
  a+b+c

 

     上面的代码中f1和f2的类型是不一样的。

     f1的函数类型是int->int->int->int，而f2的函数类型是int*int*int->int。

     我把f1函数称为柯里化函数风格，而把f2函数称为元组函数风格。

     之所以称f1为柯里化的函数风格，是因为f1可以进行柯里化的函数调用，可以部分地传入参数值。而f2则必须全部传入。    

     两种函数风格的适用场景是什么了？

     柯里化的函数很显然比较适合扮演高阶函数。根据我目前所理解，在不讨论互操作的情况下，元组类型风格的函数总是可以通过柯里化的函数风格代替的。在不需要互操作的情况下，应该优先使用柯里化的函数风格，因为柯里化的函数可以更好的组合，从这个角度来说，柯里化的函数风格可以很好的组合代码，而元组类型的函数风格则用来组合数据。

     为什么说在互操作场景中优先使用元组类型的函数风格?

     回答上面的问题，则要讨论一下元组类型真正的类型是什么？什么叫元组类型真正的类型呀，元组类型不就是元组类型吗？呵呵，绕起来了。

     

let tuple_3=(1,2,3) 

 

     上面的tuple_3元组类型是int*int*int，这是对的。但这只是表面，实质上它的真实类型是Tuple<int,int,int>，F#编译器做了手脚。Tuple类型定义了一个泛型的记录类型，它有三个元素。

 

 type Tuple<'a,'b,'c> = 
    { Item1: 'a; Item2: 'b; Item3: 'c }

     

     在F#中，一共定义了六个泛型版的元组类型。从2个元素到七个元素的元组类型。很显然，元组类型最少两个元素，最多没有限制，理论上肯定是只要内存足够就可以了。F#如何处理超过七个元素的元组类型的了。根据我的测试，发现如果超过七个元素，超过的元素将变成一个嵌套的元组的成员，依此类推。举个例子：

 

let TestTupleWithGreaterThanSeven(a, b, c ) =
   (a,b,c,a+b,a+c,b+c,a+b+c,10*a+2*b+c)

    

      上面的F#函数对应的c#方法签名是：

 

public static Tuple<int, int, int, int, int, int, Tuple<int, int>> TestTupleWithGreaterThanSeven(int a, int b, int c);

     

     注意上面的讨论是针对函数返回值的。对于函数输入参数并不适用，我们要分别讨论。

     对于函数来说，元组类型的函数风格与柯里化的函数风格，对于c#来说，并没有区别。或者说，柯时化的函数风格和元组类型的函数风格都会转化为c#方法风格。

 

let TestTuple(a, b, c,d,e,f,g,h ) =
    a+b+c+d+e+f+g+h

let TestCurrying a b c d e f g h =
    a+b+c+d+e+f+g+h

 

     对应的c#方法签名:

     

 public static int TestCurrying(int a, int b, int c, int d, int e, int f, int g, int h);
 public static int TestTuple(int a, int b, int c, int d, int e, int f, int g, int h);

 

     一个有趣的例子：

 

let tuple_7=(1,2,3,4,5,6,(7,8,9))

let tuple_9=(1,2,3,4,5,6,7,8,9)

     上面的tuple_7和tuple_9在F#中是完全不同的类型，但对于c#来说，却是完全等效的。

 

     但当我们在类型上使用这两种风格的函数时就发生了变化，这种变化还很大。下面我就定义一个记录类型：

     

type Order = 

   {ID:string;Name:string;CreateDate:System.DateTime;Remark:string option}
    with 
    static member CreateWithCurrying id name createdate remark =
        {ID=id;Name=name;CreateDate=createdate;Remark=remark}
    static member CreateWithTuple(id, name, createdate, remark) =
       {ID=id;Name=name;CreateDate=createdate;Remark=remark}

     

     我创建了一个记录类型，叫Order,并使用静态成员方法创建类型实例。

     c#签名如下:

     

 public static FastFunc<string, FastFunc<DateTime, FastFunc<Option<string>, TupleTest.Order>>> CreateWithCurrying(string id);
        public static TupleTest.Order CreateWithTuple(string id, string name, DateTime createdate, Option<string> remark);
    

          

     这意味着什么，这意味着当我们在F#中使用柯里化风格的函数作为公开接口时，不是c#程序员习惯的调用方式。而采用元组风格的函数与c#程序员的习惯是一致的。

     在F#中元组的存在，使得接受多值的返回值时，F#比C#处理方式漂亮的多。 

 

match DateTime.TryParse("2008-8-25") with
| true, d -> printfn "%s" (d.ToString())
| _ -> printfn "datetime parse error"

         

 

     五、总结：

     (1) 元组类型一般用做临时数据的容器。业务数据结构应该选用记录类型或类、结构。

     (2) 当需要与其他.net语言互操作时，元组类型用做方法或函数的输入参数，有更好的兼容性，除非你的确需要柯里化的函数风格。在互操作时，元组类型不要作为函数的返回值，如果使用元组类型作为函数返回值，互操作的语言就必须引用F#的特定函数库。

     (3) 元组类型与模式匹配语法相结合，可以很好的组合、拆分。

       

     下一篇：F#学习之路(6)列表类型