type StateError =

    | AlreadyExists

    | NotFound

    | Custom of string

​

type State<'T> = 

    | Failed of StateError

    | Fulfilled of 'T

​

let valueToState (v : 'T) : State<'T> = 

    Fulfilled v

let failState (err: StateError) (refail: bool) (state: State<'T>): State<'T> =

    match state with

    | Failed e ->

        if refail then

            Failed err

        else

            Failed e

    | Fulfilled _ -> Failed err

​

let close (state : State<'T>) : 'T option = 

    match state with

    | Failed _ -> 

        printfn "Rollback"

        None

    | Fulfilled v -> Some v

let condition (test: 'T -> bool) (thenExp: State<'T> -> State<'U>) (elseExp: State<'T> -> State<'U>) (state: State<'T>) : State<'U> =

    match state with

    | Failed e -> Failed e

    | Fulfilled v ->

        if test v then

            thenExp state

        else

            elseExp state

​

let stateEffect (effect : State<'T> -> unit) (state : State<'T>) : State<'T> =

    effect state

    state

let fulfilledStateEffect (effect: 'T -> unit) (state: State<'T>) : State<'T> =

    stateEffect

        (fun s ->

            match s with

            | Failed _ -> ()

            | Fulfilled v -> effect v)

        state

let failedStateEffect (effect: StateError -> unit) (state: State<'T>) : State<'T> =

    stateEffect

        (fun s ->

            match s with

            | Failed e -> effect e

            | Fulfilled _ -> ())

        state

​

let log (state : State<'T>) : State<'T> = 

    match state with

    | Failed e -> 

        printfn "[Log] Failed with %A" e

        Failed e

    | Fulfilled v -> 

        printfn 

            "[Log] Fulfilled with %A" v

        Fulfilled v

​

let checkAccountExists (state : State<string>) : State<unit> =

    match state with

    | Failed e -> Failed e

    | Fulfilled code -> 

        if code = "A" || code = "B" then 

            Fulfilled ()

        else

            Failed NotFound

let checkAccountNotExists =

    checkAccountExists >>

        (function

        | Failed e ->

            match e with

            | NotFound -> Fulfilled ()

            | _ -> Failed e

        | Fulfilled _ -> Failed AlreadyExists)

​

let insertAccount (account : unit) (state : State<unit>) : State<unit> = 

    match state with

    | Failed e -> Failed e

    | Fulfilled _ -> 

        printfn "Created account"

        Fulfilled()

​

let conditionalTest (i : int) = 

    valueToState i

    |> condition

        (fun i -> i > 10) 

        (fulfilledStateEffect (printfn "%i is more than 10"))

        (failState (Custom (sprintf "%i is not more than 10" i)) false)

    |> log

    |> close

    |> ignore

​

let accountInsertTest (code : string) = 

    valueToState code

    |> log

    |> checkAccountNotExists

    |> log

    |> log

    |> insertAccount()

    |> log

    |> close

    |> ignore

​

printfn "conditionalTest 1"

conditionalTest 1

printfn ""

​

printfn "conditionalTest 2"

conditionalTest 10

printfn ""

​

printfn "accountInsertTest 1"

accountInsertTest ("A")

printfn ""

​

printfn "accountInsertTest 2"

accountInsertTest ("C")

printfn ""

​

// Buchung erstellen

// 1. Kontos prüfen (To, From)

//    -> Some to, Some from -> Ok

//        -> Prüfe, ob beide Konten existieren

//    -> Some to, None -> Ok

//        -> Prüfe, ob To-Konto existiert

//    -> None, Some from -> Ok

//        -> Prüfe, ob From-Konto existiert

//    -> None, None -> Fehler!

//        -> Weitere Prüfung hinfällig!

//    > Könnte mit einer "atLeast"- und einer "withOption"-Funktion umgesetzt werden.

// 2. From-Konto belastbar?

//    -> Mindest-Kontostand prüfen

//    -> Errechne neuen Kontostand

//    -> Konto belasten

// 3. To-Konto bebuchen

// 4. Buchungssatz einfügen

​