몇 가지 디자인 모델 이 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())