几种设计模式在F#中的实现

责任链模式（在F#中的实现：）

         以下示例代码：确保人的年龄在18到65之间，体重不超过200，身高大于120

        type Record = {

     Name : string;



     Age : int;



     Weight: float;



     Height: float;}



 



let ChainOfResponsibility() =



     let validAge (record:Record) =



         record.Age < 65 && record.Age > 18



     let validWeight (record:Record) =



         record.Weight < 200.



     let validHeight (record:Record) =



         record.Height > 120.



 



     let check (f:Record->bool) (record:Record, result:bool) =



         if result=false then (record, false)



         else (record, f(record))



 



     let chainOfResponsibility =



          check(validAge) >> check(validWeight) >> check(validHeight)



     let john = { Name = "John"; Age = 80; Weight = 180.; Height=180. }



     let dan = { Name = "Dan"; Age = 20; Weight = 160.; Height=190. }



 



     printfn "john result = %b" ((chainOfResponsibility (john, true)) |> snd)



     printfn "dan result = %b" ((chainOfResponsibility (dan, true)) |> snd)

 

 

修饰模式

     以下在F#中实现了修饰模式，修饰模式对一个对象在运行时添加新的功能

type Divide() =



    let mutable divide = fun (a,b) -> a / b



    member this.Function



        with get() = divide



        and set(v) = divide <- v



    member this.Invoke(a,b) = divide (a,b)



 



let decorate() =



    let d = Divide()



    let checkZero (a,b) = if b = 0 then failwith "a/b and b is 0" else (a,b)



   



    try



        d.Invoke(1, 0) |> ignore



    with e -> printfn "without check, the error is = %s" e.Message



 



    d.Function <- checkZero >> d.Function



    try



        d.Invoke(1,0) |> ignore



with e -> printfn "after add check, error is = %s" e.Message



 

 

F#中的观察者模式

type Subject() =



    let mutable notify = fun _ -> ()



    member this.Subscribe (notifyFunction) =



        let wrap f i = f(i); i



        notify <- (wrap notifyFunction) >> notify



    member this.Reset() = notify <- fun _ -> ()



    member this.SomethingHappen(k) =



        notify k



type ObserverA() =



    member this.NotifyMe(i) = printfn "notified A %A" i



type ObserverB() =



    member this.NotifyMeB(i) = printfn "notified B %A" i



 



let observer() =



    let a = ObserverA()



    let b = ObserverB()



    let subject = Subject()



    subject.Subscribe(a.NotifyMe)



    subject.Subscribe(b.NotifyMeB)



    subject.SomethingHappen("good")

 

 

F#中的策略模式

let quicksort l =



    printfn "quick sort"



let shellsort l =



    printfn "shell short"



let bubblesort l =



    printfn "bubble sort"



type Strategy(sortFunction) =



    member this.SortFunction with get() = sortFunction   



    member this.Execute(list) = sortFunction list



 



let strategy() =



    let s = Strategy(quicksort)   



    s.Execute([1..6])



 



strategy()



 

 

F#中的状态模式

   利率被内部状态（账户余额）所决定

type AccountState =



    | Overdrawn



    | Silver



    | Gold



[<Measure>] type USD



type Account<[<Measure>] 'u>() =



    let mutable balance = 0.0<_>  



    member this.State



        with get() =



            match balance with



            | _ when balance <= 0.0<_> -> Overdrawn



            | _ when balance > 0.0<_> && balance < 10000.0<_> -> Silver



            | _ -> Gold



    member this.PayInterest() =



        let interest =



            match this.State with



                | Overdrawn -> 0.



                | Silver -> 0.01



                | Gold -> 0.02



        interest * balance



    member this.Deposit(x:float<_>) = 



        let (a:float<_>) = x



        balance <- balance + a



    member this.Withdraw(x:float<_>) = balance <- balance - x



 



let state() =



    let account = Account()



 



    account.Deposit(10000.<USD>)



    printfn "interest = %A" (account.PayInterest())



 



    account.Withdraw(20000.<USD>)



    printfn "interest = %A" (account.PayInterest())