函数在函数式编程语言中是一等公民，是函数式语言中最重要的基本组成元素，也是其名称的由来。

F# 中的函数之如C#中的类，是组织程序结构的最基本单元。是命令式编程语言中函数或OO编程语言中方法的超集。超集，有多强大？我将在下面几个方面细细道来。

F#是一种多范式的编程语言。支持命令式、函数式、面向对象的编程范式，还有目前火热的面向语言编程(DSL)。本文不会介绍其他的编程范式,只介绍函数式编程范式。

在面向对象编程的世界里，视命令式或过程式是一种丑陋的编程方式，至少被大多数程序员视为不能有效发挥OO语言强大功效的编程方法。在函数式编程世界里，同样会认为命令式、OO的编程范式只是辅助的编程方法。过程式的流程控制语句被认为是不适宜的，if else 的条件判断被替代为模范匹配，while,for的循环语句也替代为使用尾递归的递归函数。尽管F#支持其他两种编程范式，但还是应限定在特定的场景下，应主要以函数式编程范式为主，我将在以后专门写一篇blog来探讨F#中各种编程范式相应的适用场合。

本文假设已经使用了#light指令,下面的代码风格都是轻量的。注意#light指令要求你严格的缩进，空格被视为语法的一部分，同一层级的语句之间必须严格的对齐。为了方便的缩进，请设置tab为插入空格代替，我在前文 《F#学习之路 (1)什么是函数式编程》已有介绍设置的方法。

1、如何定义一个普通函数

F#中函数分为递归函数和非递归函数，我把非递归函数称为普通函数。F#中函数默认是不能递归的。

代码一：

Code
 1     let f0 () =25 
 2
 3     let f1 x =x+1 
 4
 5     let f11 _ =1/0 
 6
 7     let f2 x y=x+y 
 8
 9     let f3 (x:float) (y:float) (z:float):string =sprintf "%f" ( x*y*z) 
10
11     let isEven =fun x -> x %2=0 
12
13     let fn f x= 
14
15          match isEven x with 
16
17          | true -> f(x) 
18
19          | false ->() 
20
21     let print_even x= fn ( fun x -> printfn "%d is even" x) x 
22
23     print_even 20 
24
25

上面的代码，你能够全部读懂吗?。

在F#中一切皆是表达式，记得这一点非常重要。这不同于命令式编程范式有语句概念。

什么是表达式，从学习c语言开始，给我灌输的概念是，表达式由运算符、常量、变量组成，表达运算产生结果值。我仍沿用这个概念，不过这个运算符、常量、变量有了新变化 。运算符是函数，大多数运算符允许你重新定义。默认定义的标识符是常量，不可变，变量使用mutable关键字指定。函数是表达式，lambda(可理解为匿名函数)是表达式，就连过程式的if else也是表达式，有运算结果值。需要指出的是在F#中，函数的返回值是由最后一个表达式计算的结果值，并且不能使用return 关键字指定。在循环结构while,for中也不能使用return。break目前版本用做保留关键字，return只能用做工作流中(一种使用monad算子的语法糖,我将在后面简述)，while,for 表达式的结果值为(),()为Unit类型的实例，相当于C系列的void。因为没有了return,break,在F#中过程式的代码控制能力是受限的，要编写break,return的语义，你需要借助闭包和递归函数，所以你还是转变一下思维吧。

代码二：

Code
1 let unit=print_even 20 
2 
3 printfn "%A" unit 
4 
5 let value=if 3/2=1 then true else false; 
6 
7 printfn "%A" value 
8 
9 

上面这段代码演示了如何接受unit结果值和if else表达式返回的结果值

让我们回到正题。我来解释一下代码一的片段。

let f0 () =25

f0是函数名称，他带有一个参数，参数类型为Unit类型，返回值为整型25 。函数签名或类型为 val f0:unit->int。

F#是一种强类型的语言，是严格的函数式语言，而不是惰性函数语言，尽管他提供了一些有效的方法来支持惰性。是强类型的语言，那为什么没有类型声明了。

F#来自于ML家族，其语法规则主要借鉴OCmal，他使用类型推断技术，根据上下文来推断类型信息。

let f1 x =x+1

函数f1，他带有一个参数x,参数类型为int型，返回值为整型。函数签名为val f1:int->int。F#是如何推断出函数的参数类型和返回值类型的，在F#中 (+)操作符，其操作数1为整数，所以要求x只能是整型，(+)函数的返回值为整数，所以可以推断出f1的类型。

注意的是f0,f1的参数书写，在c#中方法的参数是需要括号的，而在F#的括号是可以省略的，更需要指出的是f0的()不能看成是括号，而是Unit类型的实例。有意思的是在目前的版本中unit 的值()，左括号与右括号之间可以有任意的空格。这不符合人们的认知。因为实例标识应是固定的，这也是造成人们视()为符号括号的主要原因。上面的f1可以写作 let f1 (x) =x+1 ，因为在F#中括号可以省略，所以官方给出的代码大都省略了。

let f11 _ =1/0

这段代码跟f1的定义，有两点需要指出。一个就是参数使用了 下划线 _，这表示参数可以使用任何类型。二是函数体中的1/0，这在c#中无法编译通过的，而在F#中(/)运算符是函数，所以只会在运行时出现除零错。F11的函数签名为val f11:'a->int，'a表示这是一个泛型类型，因为没有约束，所以可以接受任何类型

let f2 x y=x+y

F#中多个参数之间使用空格分隔，而不是使用逗号。这个函数签名为val f2:int->int->int，表示有两个int型参数，返回值为int型。

注意这个定义 ：let f22 (x,y)=x+y

f2与f22有很大的区别,f22表示的是一个参数，其类型为元组(tuple)类型，返回值为int型,在F#中元组类型使用(x,y,z)方式定义。元组表示 一组类型值的集合，可为相同的类型也可为不同的类型，元组是F#的原生类型，也意味着函数的返回值可以返回一个元组类型的值，方便我们返回多值。f22的函数签名为val f22:int*int->int。

let f3 (x:float) (y:float) (z:float):string =sprintf "%f" ( x*y*z)

函数f3有三个参数，都是浮点型，c#的double类型,返回值为string，函数签名为 val:float->float->float->string,f3的函数定义使用显示指定类型，F#的( * )操作符默认同样是操作int型的，所以通过显示指定的方法，强制f#编译器使用float类型参数。函数返回值类型在这个例子中可以不指定，因为sprintf函数返回值是string类型，F#可以推断出f3的返回值是string类型。

let isEven =fun x -> x %2=0

F#支持lambda表达式，lambda表达式可以视为匿名函数。isEven接受一个lambda表达式，他的签名为val isEven:int->bool，从签名中可以看出他等同于let isEven x=x%2=0。

let fn f x=

match isEven x with

| true -> f(x)

| false ->()

函数式语言通常都有一种语法叫模式匹配(Pattern Match),他比c#中swith语句强大的多，不仅可以匹配基本原生类型，还支持通过自定义活动模式（Active Pattern,据我所知，这种语法只有F#提供了），来扩展。你可以理解为模式匹配为高级多态。

上句表示，如果某个整型数是偶数，那么叫执行一个函数f,否则返回()。函数式的模式匹配可以让我们消除编写if else，swith之类的条件判断语句的需要。

函数fn的签名为val fn:(int->unit)->int->unit

let print_even x= fn ( fun x -> printfn "%d is even" x) x

print_even 20

上面的代码演示了如何调用函数print_even，如何把lambda表达式作为参数传递

2.如何定义递归函数

递归函数表示一个函数可以调用自身,一般的递归函数会大量的使用堆栈。但尾递归则不会,尾递归会使用迭代来代替递归。

Code
 1let breakn n (l:'a[]) = 
 2
 3    let i =ref 0 
 4
 5    let rec iter () = 
 6
 7        if !i>n then () 
 8
 9        else 
10
11            printf "%A" l.[!i] 
12
13            i :=!i+1 
14
15            iter () 
16
17    iter () 
18
19 
20
21breakn 8 [|0..10|] 
22
23

上面的代码演示了有break语义函数。breakn是一个普通函数，它有两个参数，一个是整型n,另一个是l，泛型数组。返回值是unit

let i =ref 0

i是一个int ref型的值，它引用了整数0，实际上ref是泛型函数，它返回一个Ref记录类型,它的定义类似下面:

Code
1 type Ref<'a>={mutable contents:'a} 
2 
3 let ref a={contents=a} 
4 
5 

breakn函数体内又定义了一个函数，而且这个函数使用了rec关键字,这说明两点，在F#中函数可以内嵌，第二，递归函数要使用rec关键字来说明

ref类型的操作有一些不同，反引用ref类型值使用感叹符!，而赋值使用:=。

上面的代码编译后，通过Reflector反编译为c#代码，可以看到变成了while循环。

下一篇：F# 学习之路(2) 深刻理解函数(下)