Y分钟速成X

// 单行注释以双斜杠开头
(* 多行注释以包裹在 (* , *) 之间
多行注释至此结束- *)

// ================================================
// 基础语法
// ================================================

// ------ "变量" (实际上默认不可变) ------
// "let" 关键字可定义一个（不可变的）变量
let myInt = 5
let myFloat = 3.14
let myString = "hello" // 注意，并不需要指定类型

// 可变变量用 "mutable" 标注
let mutable a=3
a <- 4 // a现在的值是4

// 稍有不同的可变变量
// Reference cell是一种容器，允许您使用引用语义来创建可变变量（create mutable values with reference semantics）
// 译者注：和Rust的RefCell类似，提供容器内部的可变性
// 详见 https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/reference-cells
let xRef = ref 10
printfn "%d" xRef.Value // 10
xRef.Value <- 11
printfn "%d" xRef.Value // 11

let a = [ref 0; ref 1] // 装有可变元素的列表
a[0].Value <- 2

// ------ 列表Lists ------
let twoToFive = [2; 3; 4; 5]     // 使用方括号创建列表
                                 // 元素间使用**分号**分隔
let oneToFive = 1 :: twoToFive   // :: 创建新列表，并将新元素添加到开头
// 结果为 [1; 2; 3; 4; 5]
let zeroToFive = [0; 1] @ twoToFive   // @ 可合并两个列表

// 重要提示：是使用分号来分隔语句，而不是逗号！！

// ------ 函数 ------
// "let" 关键字也可以用来定义函数
let square x = x * x          // 注意，没有使用圆括号
square 3                      // 注意，运行函数时也不需要圆括号

let add x y = x + y           // 切勿将参数写成 (x, y)！
                              // 这是元组Tuple的写法（稍后介绍），
                              // 和函数参数完全不同
add 2 3                       // 调用该函数

// 使用缩进来定义一个多行的复杂函数。不需要写分号
let evens list =
   let isEven x = x % 2 = 0   // 定义**子函数** "isEven"。
                              // 注意“相等”是使用单等号'='而不是双等号"=="
   List.filter isEven list    // List.filter 是个 F# 库函数，它有两个参数：
                              // - 返回值为boolean的函数
                              // - 待处理的列表

evens oneToFive               // 调用该函数

// 圆括号可用于显式地标注计算优先级。在下述示例代码中：
// 1. 首先进行 List.map 计算，该函数具有两个参数
// 2. 然后进行 List.sum 计算，将上一步的结果作为该步的参数
// 若不写圆括号，"List.map" 就会被当作参数传递给 List.sum

let sumOfSquaresTo100 =
   List.sum ( List.map square [1..100] )

// 使用管道操作符 "|>" ，可以将上一步的输出（译者注：即返回值）输送给下一步作为输入
// 管道操作在 F# 中很常见，其语义也与 UNIX 操作系统中的管道操作非常相似。

// 使用管道操作符，可将 sumOfSquares 函数重构为如下形式：
let sumOfSquaresTo100piped =
   [1..100] |> List.map square |> List.sum  // "square" 函数就是之前定义的，求平方的函数

// 匿名函数（或作lambda函数）可用 "fun" 关键字定义
let sumOfSquaresTo100withFun =
   [1..100] |> List.map (fun x -> x * x) |> List.sum

// F# 中没有"return" 关键字，因为函数总是返回最后一个表达式的值。

// ------ 模式匹配 ------
// 模式匹配 match..with.. 是个加强版的 case/switch 
let simplePatternMatch =
   let x = "a"
   match x with
    | "a" -> printfn "x is a"
    | "b" -> printfn "x is b"
    | _ -> printfn "x is something else"   // 下划线可匹配任意值

// F# 默认不支持空值（null），您必须使用Option类型以便随后进行模式匹配
// Some(..) 和 None 均为Option类型的一种，用于表示"可能为空值"的两种情况
let validValue = Some(99)
let invalidValue = None

// 在下列示例中，match..with 不仅匹配了 "Some" 和 "None" 两种情况，
// 还同时将 "Some" 中的内容给解包出来了
let optionPatternMatch input =
   match input with
    | Some i -> printfn "input is an int=%d" i
    | None -> printfn "input is missing"

optionPatternMatch validValue
optionPatternMatch invalidValue

// ------ 打印内容 ------
// printf/printfn 函数与 C# 中的 Console.Write/WriteLine 函数类似
printfn "Printing an int %i, a float %f, a bool %b" 1 2.0 true
printfn "A string %s, and something generic %A" "hello" [1; 2; 3; 4]

// 若要按一定格式生成字符串，可以使用 sprintf/sprintfn 函数，
// 它们与 C# 中的 String.Format 函数类似

// ================================================
// 函数漫谈
// ================================================

// F# 是函数式编程语言：函数是其一等公民，通过组合不同函数可以实现强大的功能

// 模块（Modules）可以将一系列函数组织到一起
// 每个模块使用标识符（Indentation）来唯一标记
module FunctionExamples =

    // 定义一个简单的求和函数
    let add x y = x + y

    // 函数的基础使用
    let a = add 1 2
    printfn "1 + 2 = %i" a

    // 函数的“部分应用”（partial application）可事先“固化”参数
    let add42 = add 42
    let b = add42 1
    printfn "42 + 1 = %i" b

    // 函数的组合（composition）可将多个函数“串接”起来
    let add1 = add 1
    let add2 = add 2
    let add3 = add1 >> add2
    let c = add3 7
    printfn "3 + 7 = %i" c

    // 高阶函数
    [1..10] |> List.map add3 |> printfn "new list is %A"

    // 函数列表，以及 List.reduce 函数
    let add6 = [add1; add2; add3] |> List.reduce (>>)
    let d = add6 7
    printfn "1 + 2 + 3 + 7 = %i" d

// ================================================
// 列表与集合（collection）
// ================================================

// F# 内置了三种有序集合：
// * 列表（List）是最基本的、不可变的集合类型
// * 数组（Arrays）是可变的，按需使用可令程序更高效
// * 序列（Sequences）是惰性的、无限的集合类型（例如枚举器enumerator）
//
// 除此以外，还有诸如不可变哈希表、不可变哈希集合、
// 以及所有 .NET 中定义的标准集合类型等

module ListExamples =

    // 列表使用方括号
    let list1 = ["a"; "b"]
    let list2 = "c" :: list1    // :: 将元素添加到开头
    let list3 = list1 @ list2   // @ 将两个列表连接起来

    // 列表推导式（list comprehensions），也被称为生成器（generators）
    let squares = [for i in 1..10 do yield i * i]

    // 素数生成器
    // - 本例采用了模式匹配的简写语法
    // - (p::xs) 匹配列表的 “第一个元素 :: 其余所有元素” ，写成 p :: xs也可以
    //   此时，p匹配到列表的第一个元素，而其余元素被xs匹配到
    //   这种写法被称为构造模式（cons pattern）
    // - 在写递归函数时，必须使用 "rec" 关键字
    let rec sieve = function
        | (p::xs) -> p :: sieve [ for x in xs do if x % p > 0 then yield x ]
        | []      -> []
    let primes = sieve [2..50]
    printfn "%A" primes

    // 对列表进行模式匹配
    let listMatcher aList =
        match aList with
        | [] -> printfn "the list is empty"
        | [first] -> printfn "the list has one element %A " first
        | [first; second] -> printfn "list is %A and %A" first second
        | first :: _ -> printfn "the list has more than two elements, first element %A" first

    listMatcher [1; 2; 3; 4]
    listMatcher [1; 2]
    listMatcher [1]
    listMatcher []

    // 接受列表作参数的递归函数
    let rec sum aList =
        match aList with
        | [] -> 0
        | x::xs -> x + sum xs
    sum [1..10]

    // -----------------------------------------
    // 列表的标准库函数
    // -----------------------------------------

    // map
    let add3 x = x + 3
    [1..10] |> List.map add3

    // filter
    let even x = x % 2 = 0
    [1..10] |> List.filter even

    // 还有很多，详见文档

module ArrayExamples =

    // 数组（Array）用 [| 和 |] 包裹
    let array1 = [| "a"; "b" |]
    let first = array1.[0]        // 用 . 来索引元素

    // 数组和列表的模式匹配语法完全相同
    let arrayMatcher aList =
        match aList with
        | [| |] -> printfn "the array is empty"
        | [| first |] -> printfn "the array has one element %A " first
        | [| first; second |] -> printfn "array is %A and %A" first second
        | _ -> printfn "the array has more than two elements"

    arrayMatcher [| 1; 2; 3; 4 |]

    // Array的标准库函数和List也几乎一样

    [| 1..10 |]
    |> Array.map (fun i -> i + 3)
    |> Array.filter (fun i -> i % 2 = 0)
    |> Array.iter (printfn "value is %i. ")


module SequenceExamples =

    // 序列（Sequence）用大括号包裹
    let seq1 = seq { yield "a"; yield "b" }

    // 序列可以使用 "yield" 关键字，也可以包含子序列
    let strange = seq {
        // "yield" 向序列中增添1个元素
        yield 1; yield 2;

        // "yield!" 则是增添一个子序列
        yield! [5..10]
        yield! seq {
            for i in 1..10 do
              if i % 2 = 0 then yield i }}
    // 试试看吧！
    strange |> Seq.toList


    // 序列可以通过 "Seq.unfold" 函数来创建
    // 下例演示如何用这个函数创建斐波那契数列
    let fib = Seq.unfold (fun (fst,snd) ->
        Some(fst + snd, (snd, fst + snd))) (0,1)

    // 试试看吧！
    let fib10 = fib |> Seq.take 10 |> Seq.toList
    printf "first 10 fibs are %A" fib10


// ================================================
// 数据类型
// ================================================

module DataTypeExamples =

    // 默认情况下，所有的数据类型均是不可变的

    // 元组（Tuple）是一种简单快捷的匿名类型
    // -- 使用逗号即可创建元组
    let twoTuple = 1, 2
    let threeTuple = "a", 2, true

    // 同样，使用模式匹配来解包元组
    let x, y = twoTuple  // x, y分别被赋值为1, 2

    // ------------------------------------
    // 记录（Record）类型由命名域构成（译者注：类似class的成员变量）
    // 译者注：由于“记录”一词听起来像动词，下文将以英文原文Record来指代
    // ------------------------------------

    // 使用 "type" 关键字和大括号来定义Record类型
    type Person = {First:string; Last:string}

    // 使用 "let" 关键字和大括号来创建Record实例
    let person1 = {First="John"; Last="Doe"}

    // 同样，使用模式匹配来解包Record实例
    let {First = first} = person1    // first被赋值为"John"

    // ------------------------------------
    // 联合类型（Union或Variants，类似于Rust中的枚举类型）拥有一系列的取值选项。其实例仅能从中取其一。
    // 译者注：由于联合类型与Rust中的枚举类型（enum）很相似，故后文将以“枚举类型”指代之
    // ------------------------------------

    // 使用 "type" 关键字和竖线/管道符来定义枚举类型
    type Temp =
        | DegreesC of float
        | DegreesF of float

    // 使用一个选项来创建枚举实例
    let temp1 = DegreesF 98.6
    let temp2 = DegreesC 37.0

    // 模式匹配可以解包枚举实例
    let printTemp = function
       | DegreesC t -> printfn "%f degC" t
       | DegreesF t -> printfn "%f degF" t

    printTemp temp1
    printTemp temp2

    // ------------------------------------
    // 递归类型
    // ------------------------------------

    // 类型可以通过递归组合成复杂的类型，无需创建子类
    type Employee =
      | Worker of Person
      | Manager of Employee list // 译者注：这儿发生了递归定义

    let jdoe = {First="John"; Last="Doe"}
    let worker = Worker jdoe

    // ------------------------------------
    // 使用枚举类型建模
    // ------------------------------------

    // 枚举类型非常适合用于表述某种状态，再也不需要用数字等标志位（flag）来表征状态啦！
    type EmailAddress =
        | ValidEmailAddress of string   // 状态：合法邮件地址
        | InvalidEmailAddress of string // 状态：不合法邮件地址

    let trySendEmail email =
        match email with // 使用模式匹配
        | ValidEmailAddress address -> ()   // 可以发送
        | InvalidEmailAddress address -> () // 不能发送

    // 组合使用枚举类型和Record类型为“域驱动的软件设计”（Domain Driven Design）提供了良好基础。
    // 您可以定义数以百计的类型，每一种都精准地反映着一个域（Domain）

    type CartItem = { ProductCode: string; Qty: int }
    type Payment = Payment of float
    type ActiveCartData = { UnpaidItems: CartItem list }
    type PaidCartData = { PaidItems: CartItem list; Payment: Payment}

    type ShoppingCart =
        | EmptyCart  // 空购物车，没有数据
        | ActiveCart of ActiveCartData
        | PaidCart of PaidCartData

    // ------------------------------------
    // 数据类型的内置行为
    // ------------------------------------

    // 核心数据类型提供了开箱即用的默认行为与性质，无需额外编码。
    // * 不可变性
    // * 漂亮的打印输出，在debug时尤其好用
    // * 相等性与可比性
    // * 可序列化性

    // 使用 %A 来输出复杂数据类型
    printfn "twoTuple=%A,\nPerson=%A,\nTemp=%A,\nEmployee=%A"
             twoTuple person1 temp1 worker

    // 下列扑克牌示例展示了 F# 中内置的相等性与可比较性
    type Suit = Club | Diamond | Spade | Heart
    type Rank = Two | Three | Four | Five | Six | Seven | Eight
                | Nine | Ten | Jack | Queen | King | Ace

    let hand = [ Club, Ace; Heart, Three; Heart, Ace;
                 Spade, Jack; Diamond, Two; Diamond, Ace ]

    // 排序
    List.sort hand |> printfn "sorted hand is (low to high) %A"
    List.max hand |> printfn "high card is %A"
    List.min hand |> printfn "low card is %A"


// ================================================
// 主动模式（Active patterns）
// ================================================

module ActivePatternExamples =

    // F# 中，有一种被称为“主动模式”的特殊模式匹配
    // 它可以在模式匹配中动态解析或检测模式（pattern）。
    // 译者注：译者个人倾向于把此所谓“主动模式”理解为，自定义某个数据类型在接受模式匹配时，会返回哪些情况

    // 主动匹配的语法形似 "banana clips" （译者注：确实不知道banana clips是啥意思）

    // 您可以用elif代替else if，它们在 F# 中完全等价

    // 下列示例使用主动模式去匹配不同类型的字符...
    let (|Digit|Letter|Whitespace|Other|) ch =
       if System.Char.IsDigit(ch) then Digit
       elif System.Char.IsLetter(ch) then Letter
       elif System.Char.IsWhiteSpace(ch) then Whitespace
       else Other

    // ...然后使用它，可以看到解析逻辑十分清晰
    let printChar ch =
      match ch with
      | Digit -> printfn "%c is a Digit" ch
      | Letter -> printfn "%c is a Letter" ch
      | Whitespace -> printfn "%c is a Whitespace" ch
      | _ -> printfn "%c is something else" ch

    // 用主动模式处理并打印一个列表
    ['a'; 'b'; '1'; ' '; '-'; 'c'] |> List.iter printChar

    // -----------------------------------
    // 用主动模式实现FizzBuzz
    // -----------------------------------

    // 您也可以在主动模式中实现“部分匹配”
    // 只需在定义中使用下划线，并在匹配成功时返回 Some 即可
    let (|MultOf3|_|) i = if i % 3 = 0 then Some MultOf3 else None
    let (|MultOf5|_|) i = if i % 5 = 0 then Some MultOf5 else None

    // fizzbuzz的主函数
    let fizzBuzz i =
      match i with
      | MultOf3 & MultOf5 -> printf "FizzBuzz, "
      | MultOf3 -> printf "Fizz, "
      | MultOf5 -> printf "Buzz, "
      | _ -> printf "%i, " i

    // 试试看吧！
    [1..20] |> List.iter fizzBuzz

// ================================================
// 简明的 F#
// ================================================

module AlgorithmExamples =

    // F# 代码的“信噪比”很高，阅读代码时很容易就能弄明白算法的意图

    // ------ 例子: 计算平方和 ------
    let sumOfSquares n =
       [1..n]              // 1) 取从 1 到 n 的所有整数
       |> List.map square  // 2) 给每个整数求平方
       |> List.sum         // 3) 将上一步的结果求和

    // 试试看吧！
    sumOfSquares 100 |> printfn "Sum of squares = %A"

    // ------ 例子: 排序 ------
    // 译者注：下列示例实现的是朴素的快速排序算法
    let rec sort list =
       match list with
       // 若 list 是空表...
       | [] ->
            []                            // ...则返回空表
       // 否则...
       | firstElem::otherElements ->      // 取其第一个元素
            let smallerElements =         // 从剩余元素中提取比它小的
                otherElements
                |> List.filter (fun e -> e < firstElem)
                |> sort                   // 并排序
            let largerElements =          // 同理，从剩余元素中提取比它大的
                otherElements
                |> List.filter (fun e -> e >= firstElem)
                |> sort                   // 并排序
            // 最后，将这三部分组合起来，返回一个新的列表
            List.concat [smallerElements; [firstElem]; largerElements]

    // 试试看吧！
    sort [1; 5; 23; 18; 9; 1; 3] |> printfn "Sorted = %A"

// ================================================
// 异步编程
// ================================================

module AsyncExample =

    // F# 内置了对异步编程的支持
    // 从而规避了缩进地狱问题（"pyramid of doom"）
    // 下列示例展示了如何使用异步编程，实现同时下载多个网页

    open System.Net
    open System
    open System.IO
    open Microsoft.FSharp.Control.CommonExtensions

    // 异步地访问URL，并获取其内容
    let fetchUrlAsync url =
        async {   // "async" 关键词和大括号将创建一个异步对象 （"async" object）
            let req = WebRequest.Create(Uri(url))
            use! resp = req.AsyncGetResponse()
                // use! 的意思是异步赋值，类似于JavaScript的await
            use stream = resp.GetResponseStream()
                // "use" 会让资源在当前作用域结束时自动 close()
            use reader = new IO.StreamReader(stream)
            let html = reader.ReadToEnd()
            printfn "finished downloading %s" url
        }

    // 准备以下网页喂给爬虫
    let sites = ["http://www.bing.com";
                 "http://www.google.com";
                 "http://www.microsoft.com";
                 "http://www.amazon.com";
                 "http://www.yahoo.com"]

    // 来试试看吧！
    sites
    |> List.map fetchUrlAsync  // 把每个URL都包装成一个异步任务
    |> Async.Parallel          // 令所有任务并发地运行
    |> Async.RunSynchronously  // 开始运行

// ================================================
// .NET 兼容性
// ================================================

module NetCompatibilityExamples =

    // C#能干的活，F# 基本上都能做。同时，F# 还无缝集成了 .Net 或 Mono 的库
    // 译者注：Mono库（Mono Libraries）的含义不太确定

    // ------- 使用已有的库函数  -------

    let (i1success, i1) = System.Int32.TryParse("123");
    if i1success then printfn "parsed as %i" i1 else printfn "parse failed"

    // ------- 简简单单实现接口（interface） -------

    // 创建一个实现了 IDisposable 的对象
    let makeResource name =
       { new System.IDisposable
         with member this.Dispose() = printfn "%s disposed" name }

    let useAndDisposeResources =
        use r1 = makeResource "first resource"
        printfn "using first resource"
        for i in [1..3] do
            let resourceName = sprintf "\tinner resource %d" i
            use temp = makeResource resourceName
            printfn "\tdo something with %s" resourceName
        use r2 = makeResource "second resource"
        printfn "using second resource"
        printfn "done."

    // ------- 面向对象编程 -------

    // F# 对面向对象编程的支持也很成熟，支持类、接口、虚函数等

    // 带有泛型的接口
    type IEnumerator<'a> =
        abstract member Current : 'a
        abstract MoveNext : unit -> bool

    // 带有虚函数的抽象基类
    [<AbstractClass>]
    type Shape() =
        // 只读的成员变量
        abstract member Width : int with get
        abstract member Height : int with get
        // 非虚函数
        member this.BoundingArea = this.Height * this.Width
        // 虚函数，且带有默认实现
        abstract member Print : unit -> unit
        default this.Print () = printfn "I'm a shape"

    // 具象子类，继承上述抽象基类，并覆写（override）了其中的函数
    type Rectangle(x:int, y:int) =
        inherit Shape()
        override this.Width = x
        override this.Height = y
        override this.Print ()  = printfn "I'm a Rectangle"

    // 试试看吧！
    let r = Rectangle(2, 3)
    printfn "The width is %i" r.Width
    printfn "The area is %i" r.BoundingArea
    r.Print()

    // ------- 扩展已有类的方法  -------

    // 与 C# 一样，F# 也可以使用扩展语法来扩展已有类的方法
    type System.String with
       member this.StartsWithA = this.StartsWith "A"

    // 试试看吧！
    let s = "Alice"
    printfn "'%s' starts with an 'A' = %A" s s.StartsWithA

    // ------- 事件  -------

    type MyButton() =
        let clickEvent = new Event<_>()

        [<CLIEvent>]
        member this.OnClick = clickEvent.Publish

        member this.TestEvent(arg) =
            clickEvent.Trigger(this, arg)

    // 测试效果
    let myButton = new MyButton()
    myButton.OnClick.Add(fun (sender, arg) ->
            printfn "Click event with arg=%O" arg)

    myButton.TestEvent("Hello World!")