F#个人学习笔记3(F# survey)

1、F#自定义类型,自定义类型可以将我们所需的值打包成一个类型整体，如 Student类型包含{int id ; string name}。F#自定义类型可以通过tuple(元组)或record记录来实现自定义类型。
a、在一些临时的情况下我们可以直接用元组来组合一些值 ，但这仅仅是将值进行组合，不能灵活的访问想要的信息，也没有专有类型名称
将编号和姓名打包成元组由标识符userinfo来引用
let userinfo = ( 1 , "张三" )
let id , name = userinfo //由id 和 name 来引用用户信息 , id = 1 name = "张三"
printfn "%i %s" id name
b、用元组来声明类型， 关键字type。如 type userinfo = int * string * int ,声明了类型userinfo 它包含两个整型成员和一个字符串成员。这种方式可以给组合的信息起有类型名称（通常叫它是类型组合别名或类型别名）
type userinfotype = int * string * int //用户信息类型由整型 字符串 整型组成
let user : userinfotype = ( 1 , "abc" , 1) //声明标识符user为( 1 , "abc" , 1) ，但你不知道其中哪个1代表编号id
printfn "%s" ((fun (u : userinfotype) -> //声明临时方法来将userinfotype对象变成字符串 , 这个fun方法在一行书写时(fun (u : userinfotype) ->let id , name , age = u ;in Printf.sprintf "id:%i;name: %s ;age:% i" id name age;) user
let id , name , age = u ;
Printf.sprintf "id:%i;name: %s ;age:% i" id name age;) user)
c、用record来声明类型，用record来声明类型和元组一样可以将几个类型的元素组合成一个新类型，但不同的是record中的字段是有名称的。record和javascript中的json对象颇有几分相像。
type userinfo = { Id : int ; Name : string ; Age : int }
let user = { Id = 1 ; Name = "张三" ; Age = 20 }
printfn "%s" (user.GetType().Name) //结果是userinfo ,在标识符user绑定对象时，系统仅仅根据对象中成员名称(非成员类型)在已经存在的类型中查找匹配的者，所以匹配的类型是userinfo。但是根据成员名称匹配是会有冲的。

type userinfo = { Id : int ; Name : string ; Age : int }
type userinfo2 = { Id : int ; Name : string ; Age : int }
let user = { Id = 1 ; Name = "张三" ; Age = 20 }
printfn "%s" (user.GetType().Name) //结果是userinfo2，在冲突情况下，匹配最后一个符合的情况，所以是userinfo2。如果type userinfo2 = { Id : int ; Name : int ; Age : int } 系统还是会去匹配userinfo2，原因是和成员类型无关，因为Name的类型和"张三"值类型不匹配，这里会有语法错误。

type userinfo = { Id : int ; Name : string ; Age : int }
type userinfo2 = { Id : int ; Name : string ; Age : int }
let ( user : userinfo ) = { Id = 1 ; Name = "张三" ; Age = 20 } //可以添加类型约束来指定对象类型
//或 let user = { Id = 1 ; Name = "张三" ; Age = 20 } : userinfo
printfn "%s" (user.GetType().Name) //结果是userinfo

注: let user2 = { new userinfo with Id = 2 and Name = "李四" and Age = 20} 这种写法过期，按编译器提示可以使用member关键字来为成员赋值，但具体语法如何暂不知道，有待求解。

d、联合类型，感觉上有点类似泛化的意思，但子类型并未有继承，继承是从上往下，而联合类型是从子类出发找个父类型（个人理解，请指证）

type Num = //定义联合类型Num，成员类型分别是Num.Int : int->Num , Num.Float : float -> Num , Num.Double : double -> Num
| Int of int
| Float of float
| Double of double
let i = Int 1 //声明标识符 i 并绑定值 1 : Int
let printType i = //进行模式匹配 , 这儿是进行类型匹配
match i with
| Int i -> printfn "%s" "Int"
| Float i -> printfn "%s" "Float"
| Double i -> printfn "%s" "Double"

联合类型在声明时可以用未指明的子类型，通过类型参数化来实现。类型参数有两种实现方式。用'开头加参数名的方式来声明类型参数，参数具体指代的类型在创建联合类型对象时推断确定。
type 'v Tree = //在type和联合类型之间声明类型参数，这种方式声明类型参数个数只能有一个。需要多个类型参数时可以用下面一种方式。
| TreeNode of 'v Tree * 'v Tree
| TreeNodeValue of 'v
let tree =
TreeNode (TreeNodeValue "leftRoot",
TreeNode ( TreeNodeValue "rightChild1" , TreeNodeValue "rightChild2")
)
printfn "%A" tree

type TreeView<'l,'r> = //在联合类型后有尖括号的方式来声明类型参数，这种方式有点像泛型的写法。
|TreeNode of TreeView<'l,'r> * TreeView<'l,'r>
|TreeValue of 'l * 'r
let tree2 =
TreeNode ( TreeValue (1,"a") ,
TreeNode ( TreeValue (2 , "b") , TreeValue ( 3 , "c" )))
printfn "%A" tree2

type binarytree<'v> = //一个二叉树的例子
| TreeNode of binarytree<'v> * 'v * binarytree<'v>
| NullNode of 'v
let btree =
TreeNode ( NullNode null , "a" , TreeNode ( TreeNode ( NullNode null , "c" , NullNode null ) , "b" , NullNode null))
let rec printbtree t= //用递归来遍历树
match t with
| TreeNode (leftnode , value , rightnode) -> printbtree leftnode ; printbtree rightnode ;printf "%s " value ;//后序遍历
| NullNode v -> printf "%s" ""
printbtree btree