type Result<'a> = 

    | Success of 'a

    | Failure of string

​

type ResultBuilder() =

    member m.Return a = Success(a)

    member m.ReturnFrom a = a

    member m.Bind(r,fn) =

        match r with

        | Success(a) -> fn a

        | Failure(m) -> Failure(m)

    member m.Zero() = Failure("hello world")

    member m.TryWith(r,fn) =

        try 

            r()

        with

            | ex -> fn ex

    member m.Delay f = (fun () -> f())

​

module Parser = 

    let res = ResultBuilder()

    let Combine p1 p2 fn = 

        fun a -> res { let! x = p1 a

                       let! y = p2 a

                       return fn(x,y) }

    let Combine2 p1 p2 fn =

            fun a -> res { let! x = p1 a

                           let! y = p2 a

                           return! 

                                try

                                    Success(fn(x,y))

                                with

                                    | ex -> Failure(ex.Message)

                         }

​

    let Combine3 p1 p2 fn =

            fun a -> res { let! x = p1 a

                           let! y = p2 a

                           try

                                return fn(x,y)

                           with

                                | ex -> Failure(ex.Message) |> ignore

                         }

​

​

​

let comb2 a  =

    let p1' x = Success(x)

    let p2' y = Success(y)

    let fn' (x,y) = 1/0 // div by zero

    let func = Parser.Combine2 p1' p2' fn' a

    func()

​

let comb3 a  =

    let p1' x = Success(x)

    let p2' y = Success(y)

    let fn' (x,y) = 1/0 // div by zero

    let func = Parser.Combine3 p1' p2' fn' a

    func()

​

let test2 = comb2 1

let test3 = comb3 1

open System

test2.Dump()

test3.Dump()