F#学习之路(6)列表类型

     列表在函数式编程中占据着重要的位置。在Lisp语言中，一切皆是列表，就连函数也是列表，列表在Lisp语言中发挥到了极致。F#语言列表语法来源于Ocaml，与Haskell语言也基本一致。本文只会讲解一些常用的使用方法，要很好的掌握列表，各位朋友可以google一下相关的内容。网络上对列表讨论比较深刻的大多以Haskell语言为例（Lisp语言列表很强大，但与大多数函数式语言列表的区别太大，不好借鉴）。

      一、如何定义列表

     在F#中定义一个列表，有几个方法。

     1、使用字量值

     

let  l=[ 1 ; 2 ; 3 ]

let  emptyList=List.empty

let  lista=l @ emptyList

let  listb= 0 ::lista

     

     使用中括号'[',']'，元素之间用分号分隔。不同于元组类型，元组使用'(',')'，元素之间使用逗号分隔。

     F#中的列表是链表，列表元素必须是相同类型，列表是不可变的，因此定义后将不能改变。

     F#中定义一个空列表，有三种方法。它们在使用上有一些细微的差别。

     

printfn  " %A "  ((List.empty< int >).GetType()) 

printfn  " %A "  ((List.Empty: int  list).GetType()) 

printfn  " %A "  (([]: int  list).GetType())

     

     列表上定义了一个 @ 操作符，用于将一个列表追加到另一个列表的尾部，生成一个新的列表。而 :: 操作符，则将一个元素添加到一个列表的首部，形成一个新的列表。注意所有操作的列表本身不会改变。这种行为类似.net的string类型。

     

     2、使用范围表达式

 

let  l1=[ 1 .. 10 ]

let  l2=[ 1 .. 2 .. 100 ]

let  l3=[ ' a ' .. ' z ' ]

     

     3、使用序列表达式

 

let  l4=[ for  i  in   1 .. 10   do   if   i> 4  && i< 8   then  yield i]

     

     关于序列将在以后的博客中讨论，序列是一种计算表达式的实现。

 

     二、列表比较。

     

printfn  " %b "  ([ 1 ; 2 ; 3 ]>[ 1 ; 2 ])  // true
printfn  " %b "  ([ 1 ; 2 ]=[ 1 ; 4 ])  // false

    

      列表类型可以很方便的进行值比较，要使用引用比较请使用obj.ReferenceEquals

     

printfn  " %b "  (obj.ReferenceEquals([],[]))  // true
printfn  " %b "  (obj.ReferenceEquals([ 1 ],[ 1 ]))  // false

 

     三、访问列表元素

     

printfn  " %.2f "  ([ 1 .; 2 .].[ 1 ])  // 2.00

 

     列表索引从0开始。

 

     四、使用列表类型属性     

     

printfn  " %d "  ([ 1 .. 10 ].Length)   // 10
printfn  " %d "  ([ 1 ; 2 ; 3 ].Head)    // 1
printfn  " %A "  ([ 1 ; 2 ; 3 ].Tail)   // [2;3]
printfn  " %A "  ([ 1 ; 2 ; 3 ].IsEmpty)  // false

 

     五、访问List模块操作列表 

 

 

Code
namespace FSharpLearning       

type LineNo=int

type Order= 

    {ID:string;No:string;TotalPrice:float;Status:OrderStatus;OrderItems:List<LineNo*Product>}
and Product =
    {ID:string;Name:string;Price:float}
and OrderStatus=
    New
    | Readed
    | Confirmed
    | Canceled
    | Finished

[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
module Order =
    let change_order_status status order=
        {order with Status=status}
    let sum_order_totalprice order=
        {order with TotalPrice=order.OrderItems |>List.sum_by (fun (i,product)->product.Price)}
    let add_order_items productList order=
        {order with OrderItems=productList |> List.mapi (fun i product ->(i,product))}
    let reorder order =
        {order with OrderItems=
                    order.OrderItems |> List.sort (fun (_,i) (_,j) ->compare i.Price j.Price) 
                    |>List.mapi (fun i (_,product) ->(i,product))  }
            

module ListTest=
     
      let main ()=
          let productList=List.map3 (fun id name price->{ID=id;Name=name;Price=price}) 
                            ["0001";"0002";"0003"] ["彩电";"冰箱";"PDA"] [4000.;3050.;3000.]
          
          let order={ID="0001";No="20080904"; Status=New;TotalPrice=0.;OrderItems=[]}
          let order=order |> Order.add_order_items productList 
          let order=Order.sum_order_totalprice order
          let order=order |>Order.reorder
          let order=Order.change_order_status Readed order
            
          printfn "%A" order
                                          
          do System.Console.ReadKey(true)|>ignore


      do main()                         

 

     上面的代码，使用namespace定义了一个FSharpLearning名称空间,使用type给int类型取了一个更有意义的名称LineNO。

     并且使用type定义了一个Order记录类型和Product记录类型，以及OrderStatus联合类型。

     之后使用module定义了一个子模块Order，并且这里使用[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]标注了Order模块。并告诉编译器在Order模块名后面加上Module作为模块名。前面说过顶层作用域不允许重名。

     Order模块中定义了几个函数，用来操作Order记录类型。之后，我们在ListTest模块中分别调用了这些定义的函数。

     List模块中函数较多，主要介绍三个,其它函数使用方法类似。

     

let  numbers=[ for  i  in   1 .. 100   ->  i]
numbers  | >List.iteri ( fun  i num  -> printfn  " index %d:%d "  i num)

      List.iteri函数类型为(int->'a->unit)->'a list->unit

      |>前向管道操作符。上面的字法等价于List.iteri (fun i num ->printfn "index %d:%d" i num) numbers

      List.iteri带有索引，还有一个List.iter不带索引，通常这两个函数用来遍历列表。

 

let  number=[ for  i  in   1 .. 100   -> i]

numbers  | >List.map ( fun  i -> string  i)  | >printfn  " %A "

     

     List.map的函数类型为('a->'b)->'a list->'b list

     map函数通常用来操作列表中每个元素，生成新的列表。 

 

let  numbers=[ for  i  in   1 .. 100   -> i]

numbers  | > List.reduce_left (+)  | > printfn  " %d "

 

     

     List.reduce_left函数类型为('a->'a->'a)->'a list ->'a

     reduce_left函数从左到右依次取出列表中两个元素操作。通常称为归约。

 

     六、列表与模式匹配

     

# light

let  numbers=[ for  i  in   1 .. 100   ->  i]

let   rec  print numbers=
     match  numbers  with  
     | [] -> printfn  " %s "   ""
     | [a] -> printfn  " %s "  ( string  a)
     | a::b  -> printfn  " %s "  ( string  a);print b

print numbers

do  System.Console.ReadKey( true ) | >ignore

 

     总结：

     1、列表用于表示相同类型的一组数据的集合，在F#中大数据量集合类型应优先使用seq序列，因为序列是惰性的。

     2、列表是一个combinator,列表的类型定义为:

          type 'a list=

          |([])

          |( :: ) of 'a *'a list

     一个[1;2;3]的列表本质上是1::2::3::[]，最具体的说是op_Cons(1,op_Cons(2,op_Cons(3,op_Nil)))

     op_Nil是[]的操作符名，op_Cons是::的操作符名。

     一个列表可以看作第一个元素（称为首部Head)与后面所有元素(称为尾部Tail)的组合。

     这样两个操作构成了列表的灵魂，深入研究组合子非常必要。

      下一篇：F#学习之路(7) 集合类型