F# 编程之一

1. let 绑定

F#使用let关键字来将一个变量或者函数绑定到一个标识符上。例如:

let i=5*5

结果为：

val i : int = 25

也可以绑定函数到标示符：

let f i=i*i
let j=f 5

结果为：

val f : int -> int
val j : int = 25

这表示f是一个接受一个int型参数并且返回int的函数。

2. 函数

函数是F#中的一等公民，和变量具有同等的地位。函数可以用lambda表达式来定义:

let f= fun x y->x+y
let g= fun x y->x*y

lambda表达式是由fun关键字开始，加上一组用空格隔开的参数列表，->和表达式组成。 上面两句语句的结果是定义的变量如下：

val f : int -> int -> int
val g : int -> int -> int

在F#中，多个参数的函数的概念比较特殊，它表示，这个语句定义了一个函数，它接受一个整型参数（x)，返回一个函数（int->int)，这个函数接受一个整型参数(y)，返回一个整数。

调用函数的方法是函数名加上空格再加上空格分开的参数列表，

let result = f 3 5

结果为:

val result : int = 8

本质上，根据上面的解释，可以认为F#的函数都是单变量的，只是f 3返回的是一个函数，这个函数作用在5上，得到了8.例如，我们可以这样证实这种说法:

let inc=f 1
let result=inc 5

结果为:

val inc : (int -> int)
val result : int = 6

很明显，inc等价于

let inc=fun y->1+y

F#不需要显式的指定参数的类型，但它是强类型的编程语言，它会根据定义自动推测出适当的类型，例如，f的两个参数和返回值都被定义为int。如果执行：

let result=f 3.3 4

将会报错:

error FS0001: This expression was expected to have type
    int    
but here has type
    float    

F#也允许显式的指定参数的类型:

let f= fun (x:float) (y:float)->x+y
let result=f 3.3 4.0

结果为：

val f : float -> float -> float
val result : float = 7.3

函数还可以用一种简洁的语法来定义:

let g x y=x*y

函数和普通变量是一样的，因此可以作为函数的参数，例如:

let compose f g = fun n -> f (g n)

compose函数接受两个参数，返回这个两个函数的复合。

let f= fun x -> x+1
let g x = x*2
let result=compose f g 3  

结果为 7.

注意看下compose的类型:

val compose : ('a -> 'b) -> ('c -> 'a) -> 'c –> 'b

这说明F#自动识别出compose所能能接受的类型是，第一个参数是一个函数，接受类型为a的参数，返回类型为b，第二个参数是一个函数，接受参数类型为c，返回类型为a，注意到第二个函数的返回类型必须和第一个函数的类型一致他们才能复合。返回的是一个函数，接受类型为c的参数，返回类型为b。

递归函数要用rec关键字显式声明:

let rec sum m n= if m=n then n else m+ sum (m+1) n
let res=sum 1 100

结果自然为5050

函数复合和管道

let function1 x = x + 1
let function2 x = x * 2
let h = function1 >> function2
let result = h 100

>>可以将两个函数复合，结果是202

let result = 100 |> function1 |> function2

|>可以将结果传递给下一个函数