(import "core/common")

(record Result/Ok value)
(record Result/Ex value)

(let Result/ok Result/Ok/create)
(let Result/ex Result/Ex/create)

(let Result/map (\[f m]
    (match (kind m)
        :Result/Ok (Result/ok (f (Result/Ok/get-value m)))
        :Result/Ex m)))

(let Result/map-ex (\[f m]
    (match (kind m)
        :Result/Ok m
        :Result/Ex (Result/ex (f (Result/Ex/get-value m))))))

(let Result/and-then (\[f m]
    (match (kind m)
        :Result/Ok (f (Result/Ok/get-value m))
        :Result/Ex m)))

(let Result/try (\[catch-f m]
    (match (kind m)
        :Result/Ok (Result/Ok/get-value m)
        :Result/Ex (catch-f (Result/Ex/get-value m)))))

; converts the given impure function that can throw a fatal error
; to an impure function that returns a Result
(let Result/safe! (\![fn! arg]
    (try! Result/ex (.! Result/ok fn!) arg)))