Decode.fs

namespace Thoth.Json
open System.Text.RegularExpressions

[<RequireQualifiedAccess>]
module Decode =

    open System.Globalization
    open Fable.Core
    open Fable.Core.JsInterop

    module internal Helpers =
        [<Emit("typeof $0")>]
        let jsTypeof (_ : JsonValue) : string = jsNative

        [<Emit("$0 instanceof SyntaxError")>]
        let isSyntaxError (_ : JsonValue) : bool = jsNative

        let inline getField (fieldName: string) (o: JsonValue) = o?(fieldName)
        let inline isString (o: JsonValue) : bool = o :? string

        let inline isBoolean (o: JsonValue) : bool = o :? bool

        let inline isNumber (o: JsonValue) : bool = jsTypeof o = "number"

        let inline isArray (o: JsonValue) : bool = JS.Constructors.Array.isArray(o)

        [<Emit("$0 === null ? false : (Object.getPrototypeOf($0 || false) === Object.prototype)")>]
        let isObject (_ : JsonValue) : bool = jsNative

        let inline isNaN (o: JsonValue) : bool = JS.Constructors.Number.isNaN(!!o)

        let inline isNullValue (o: JsonValue): bool = isNull o

        /// is the value an integer? This returns false for 1.1, NaN, Infinite, ...
        [<Emit("isFinite($0) && Math.floor($0) === $0")>]
        let isIntegralValue (_: JsonValue) : bool = jsNative

        [<Emit("$1 <= $0 && $0 < $2")>]
        let isBetweenInclusive(_v: JsonValue, _min: obj, _max: obj) = jsNative

        [<Emit("isFinite($0) && !($0 % 1)")>]
        let isIntFinite (_: JsonValue) : bool = jsNative

        let isUndefined (o: JsonValue): bool = jsTypeof o = "undefined"

        [<Emit("JSON.stringify($0, null, 4) + ''")>]
        let anyToString (_: JsonValue) : string = jsNative

        let inline isFunction (o: JsonValue) : bool = jsTypeof o = "function"

        let inline objectKeys (o: JsonValue) : string seq = upcast JS.Constructors.Object.keys(o)
        let inline asBool (o: JsonValue): bool = unbox o
        let inline asInt (o: JsonValue): int = unbox o
        let inline asFloat (o: JsonValue): float = unbox o
        let inline asFloat32 (o: JsonValue): float32 = unbox o
        let inline asString (o: JsonValue): string = unbox o
        let inline asArray (o: JsonValue): JsonValue[] = unbox o

    let private genericMsg msg value newLine =
        try
            "Expecting "
                + msg
                + " but instead got:"
                + (if newLine then "\n" else " ")
                + (Helpers.anyToString value)
        with
            | _ ->
                "Expecting "
                + msg
                + " but decoder failed. Couldn't report given value due to circular structure."
                + (if newLine then "\n" else " ")

    let private errorToString (path : string, error) =
        let reason =
            match error with
            | BadPrimitive (msg, value) ->
                genericMsg msg value false
            | BadType (msg, value) ->
                genericMsg msg value true
            | BadPrimitiveExtra (msg, value, reason) ->
                genericMsg msg value false + "\nReason: " + reason
            | BadField (msg, value) ->
                genericMsg msg value true
            | BadPath (msg, value, fieldName) ->
                genericMsg msg value true + ("\nNode `" + fieldName + "` is unknown.")
            | TooSmallArray (msg, value) ->
                "Expecting " + msg + ".\n" + (Helpers.anyToString value)
            | BadOneOf messages ->
                "The following errors were found:\n\n" + String.concat "\n\n" messages
            | FailMessage msg ->
                "The following `failure` occurred with the decoder: " + msg

        match error with
        | BadOneOf _ ->
            // Don't need to show the path here because each error case will show it's own path
            reason
        | _ ->
            "Error at: `" + path + "`\n" + reason

    ///////////////
    // Runners ///
    /////////////

    let fromValue (path : string) (decoder : Decoder<'T>) =
        fun value ->
            match decoder path value with
            | Ok success ->
                Ok success
            | Error error ->
                Error (errorToString error)

    let fromString (decoder : Decoder<'T>) =
        fun value ->
            try
               let json = JS.JSON.parse value
               fromValue "$" decoder json
            with
                | ex when Helpers.isSyntaxError ex ->
                    Error("Given an invalid JSON: " + ex.Message)

    let unsafeFromString (decoder : Decoder<'T>) =
        fun value ->
            match fromString decoder value with
            | Ok x -> x
            | Error msg -> failwith msg

    [<System.Obsolete("Please use fromValue instead")>]
    let decodeValue (path : string) (decoder : Decoder<'T>) = fromValue path decoder

    [<System.Obsolete("Please use fromString instead")>]
    let decodeString (decoder : Decoder<'T>) = fromString decoder

    //////////////////
    // Primitives ///
    ////////////////

    let string : Decoder<string> =
        fun path value ->
            if Helpers.isString value then
                Ok(Helpers.asString value)
            else
                (path, BadPrimitive("a string", value)) |> Error

    let guid : Decoder<System.Guid> =
        fun path value ->
            if Helpers.isString value then
                match System.Guid.TryParse (Helpers.asString value) with
                | true, x -> Ok x
                | _ -> (path, BadPrimitive("a guid", value)) |> Error
            else (path, BadPrimitive("a guid", value)) |> Error

    let unit : Decoder<unit> =
        fun path value ->
            if Helpers.isNullValue value then
                Ok ()
            else
                (path, BadPrimitive("null", value)) |> Error

    let inline private integral
                    (name : string)
                    (tryParse : (string -> bool * 'T))
                    (min : 'T)
                    (max : 'T)
                    (conv : float -> 'T) : Decoder< 'T > =

        fun path value ->
            if Helpers.isNumber value then
                let value : float = unbox value
                if Helpers.isIntegralValue value then
                    if (float min) <= value && value <= (float max) then
                        Ok(conv value)
                    else
                        (path, BadPrimitiveExtra(name, value, "Value was either too large or too small for " + name)) |> Error
                else
                    (path, BadPrimitiveExtra(name, value, "Value is not an integral value")) |> Error
            elif Helpers.isString value then
                match tryParse (Helpers.asString value) with
                | true, x -> Ok x
                | _ -> (path, BadPrimitive(name, value)) |> Error
            else
                (path, BadPrimitive(name, value)) |> Error

    let sbyte : Decoder<sbyte> =
        integral
            "a sbyte"
            System.SByte.TryParse
            System.SByte.MinValue
            System.SByte.MaxValue
            sbyte

    /// Alias to Decode.uint8
    let byte : Decoder<byte> =
        integral
            "a byte"
            System.Byte.TryParse
            System.Byte.MinValue
            System.Byte.MaxValue
            byte

    let int16 : Decoder<int16> =
        integral
            "an int16"
            System.Int16.TryParse
            System.Int16.MinValue
            System.Int16.MaxValue
            int16

    let uint16 : Decoder<uint16> =
        integral
            "an uint16"
            System.UInt16.TryParse
            System.UInt16.MinValue
            System.UInt16.MaxValue
            uint16

    let int : Decoder<int> =
        integral
            "an int"
            System.Int32.TryParse
            System.Int32.MinValue
            System.Int32.MaxValue
            int

    let uint32 : Decoder<uint32> =
        integral
            "an uint32"
            System.UInt32.TryParse
            System.UInt32.MinValue
            System.UInt32.MaxValue
            uint32

    let int64 : Decoder<int64> =
        integral
            "an int64"
            System.Int64.TryParse
            System.Int64.MinValue
            System.Int64.MaxValue
            int64

    let uint64 : Decoder<uint64> =
        integral
            "an uint64"
            System.UInt64.TryParse
            System.UInt64.MinValue
            System.UInt64.MaxValue
            uint64

    let bigint : Decoder<bigint> =
        fun path value ->
            if Helpers.isNumber value then
                Helpers.asInt value |> bigint |> Ok
            elif Helpers.isString value then
                // TODO: BigInt.TryParse has been added in Fable 2.1.4
                // Don't use it for now to support lower Fable versions
                try
                    bigint.Parse (Helpers.asString value) |> Ok
                with _ ->
                    (path, BadPrimitive("a bigint", value)) |> Error
            else
                (path, BadPrimitive("a bigint", value)) |> Error

    let bool : Decoder<bool> =
        fun path value ->
            if Helpers.isBoolean value then
                Ok(Helpers.asBool value)
            else
                (path, BadPrimitive("a boolean", value)) |> Error

    let float : Decoder<float> =
        fun path value ->
            if Helpers.isNumber value then
                Ok(Helpers.asFloat value)
            else
                (path, BadPrimitive("a float", value)) |> Error

    let float32 : Decoder<float32> =
        fun path value ->
            if Helpers.isNumber value then
                Ok(Helpers.asFloat32 value)
            else
                (path, BadPrimitive("a float32", value)) |> Error

    let decimal : Decoder<decimal> =
        fun path value ->
            if Helpers.isNumber value then
                Helpers.asFloat value |> decimal |> Ok
            elif Helpers.isString value then
                match System.Decimal.TryParse (Helpers.asString value) with
                | true, x -> Ok x
                | _ -> (path, BadPrimitive("a decimal", value)) |> Error
            else
                (path, BadPrimitive("a decimal", value)) |> Error

    let datetime : Decoder<System.DateTime> =
        fun path value ->
            if Helpers.isString value then
                match System.DateTime.TryParse (Helpers.asString value) with
                | true, x -> x.ToUniversalTime() |> Ok
                | _ -> (path, BadPrimitive("a datetime", value)) |> Error
            else
                (path, BadPrimitive("a datetime", value)) |> Error

    let datetimeOffset : Decoder<System.DateTimeOffset> =
        fun path value ->
            if Helpers.isString value then
                match System.DateTimeOffset.TryParse(Helpers.asString value) with
                | true, x -> Ok x
                | _ -> (path, BadPrimitive("a datetimeoffset", value)) |> Error
            else
                (path, BadPrimitive("a datetime", value)) |> Error

    let timespan : Decoder<System.TimeSpan> =
        fun path value ->
            if Helpers.isString value then
                match System.TimeSpan.TryParse(Helpers.asString value) with
                | true, x -> Ok x
                | _ -> (path, BadPrimitive("a timespan", value)) |> Error
            else
                (path, BadPrimitive("a timespan", value)) |> Error

    /////////////////////////
    // Object primitives ///
    ///////////////////////

    let private decodeMaybeNull path (decoder : Decoder<'T>) value =
        // The decoder may be an option decoder so give it an opportunity to check null values
        match decoder path value with
        | Ok v -> Ok(Some v)
        | Error _ when Helpers.isNullValue value -> Ok None
        | Error er -> Error er

    let optional (fieldName : string) (decoder : Decoder<'value>) : Decoder<'value option> =
        fun path value ->
            if Helpers.isObject value then
                let fieldValue = Helpers.getField fieldName value
                if Helpers.isUndefined fieldValue then Ok None
                else decodeMaybeNull (path + "." + fieldName) decoder fieldValue
            else
                Error(path, BadType("an object", value))

    let private badPathError fieldNames currentPath value =
        let currentPath = defaultArg currentPath ("$"::fieldNames |> String.concat ".")
        let msg = "an object with path `" + (String.concat "." fieldNames) + "`"
        Error(currentPath, BadPath (msg, value, List.tryLast fieldNames |> Option.defaultValue ""))

    let optionalAt (fieldNames : string list) (decoder : Decoder<'value>) : Decoder<'value option> =
        fun firstPath firstValue ->
            ((firstPath, firstValue, None), fieldNames)
            ||> List.fold (fun (curPath, curValue, res) field ->
                match res with
                | Some _ -> curPath, curValue, res
                | None ->
                    if Helpers.isNullValue curValue then
                        let res = badPathError fieldNames (Some curPath) firstValue
                        curPath, curValue, Some res
                    elif Helpers.isObject curValue then
                        let curValue = Helpers.getField field curValue
                        curPath + "." + field, curValue, None
                    else
                        let res = Error(curPath, BadType("an object", curValue))
                        curPath, curValue, Some res)
            |> function
                | _, _, Some res -> res
                | lastPath, lastValue, None ->
                    if Helpers.isUndefined lastValue then Ok None
                    else decodeMaybeNull lastPath decoder lastValue

    let field (fieldName: string) (decoder : Decoder<'value>) : Decoder<'value> =
        fun path value ->
            if Helpers.isObject value then
                let fieldValue = Helpers.getField fieldName value
                if Helpers.isUndefined fieldValue then
                    Error(path, BadField ("an object with a field named `" + fieldName + "`", value))
                else
                    decoder (path + "." + fieldName) fieldValue
            else
                Error(path, BadType("an object", value))

    let at (fieldNames: string list) (decoder : Decoder<'value>) : Decoder<'value> =
        fun firstPath firstValue ->
            ((firstPath, firstValue, None), fieldNames)
            ||> List.fold (fun (curPath, curValue, res) field ->
                match res with
                | Some _ -> curPath, curValue, res
                | None ->
                    if Helpers.isNullValue curValue then
                        let res = badPathError fieldNames (Some curPath) firstValue
                        curPath, curValue, Some res
                    elif Helpers.isObject curValue then
                        let curValue = Helpers.getField field curValue
                        if Helpers.isUndefined curValue then
                            let res = badPathError fieldNames None firstValue
                            curPath, curValue, Some res
                        else
                            curPath + "." + field, curValue, None
                    else
                        let res = Error(curPath, BadType("an object", curValue))
                        curPath, curValue, Some res)
            |> function
                | _, _, Some res -> res
                | lastPath, lastValue, None ->
                    decoder lastPath lastValue

    let index (requestedIndex: int) (decoder : Decoder<'value>) : Decoder<'value> =
        fun path value ->
            let currentPath = path + ".[" + (Operators.string requestedIndex) + "]"
            if Helpers.isArray value then
                let vArray = Helpers.asArray value
                if requestedIndex < vArray.Length then
                    decoder currentPath (vArray.[requestedIndex])
                else
                    let msg =
                        "a longer array. Need index `"
                            + (requestedIndex.ToString())
                            + "` but there are only `"
                            + (vArray.Length.ToString())
                            + "` entries"

                    (currentPath, TooSmallArray(msg, value))
                    |> Error
            else
                (currentPath, BadPrimitive("an array", value))
                |> Error

    let option (decoder : Decoder<'value>) : Decoder<'value option> =
        fun path value ->
            if Helpers.isNullValue value then Ok None
            else decoder path value |> Result.map Some

    //////////////////////
    // Data structure ///
    ////////////////////

    let private arrayWith expectedMsg (mapping: 'value[] -> 'result) (decoder : Decoder<'value>) : Decoder<'result> =
        fun path value ->
            if Helpers.isArray value then
                let mutable i = -1
                let tokens = Helpers.asArray value
                let arr = Array.zeroCreate tokens.Length
                (Ok arr, tokens) ||> Array.fold (fun acc value ->
                    i <- i + 1
                    match acc with
                    | Error _ -> acc
                    | Ok acc ->
                        match decoder (path + ".[" + (i.ToString()) + "]") value with
                        | Error er -> Error er
                        | Ok value -> acc.[i] <- value; Ok acc)
                |> Result.map mapping
            else
                (path, BadPrimitive (expectedMsg, value))
                |> Error

    let list (decoder : Decoder<'value>) : Decoder<'value list> =
        arrayWith "a list" List.ofArray decoder

    let seq (decoder : Decoder<'value>) : Decoder<'value seq> =
        arrayWith "a seq" Seq.ofArray decoder

    let array (decoder : Decoder<'value>) : Decoder<'value array> =
        arrayWith "an array" id decoder

    let keys: Decoder<string list> =
        fun path value ->
            if Helpers.isObject value then
                Helpers.objectKeys value |> List.ofSeq |> Ok
            else
                (path, BadPrimitive ("an object", value))
                |> Error

    let keyValuePairs (decoder : Decoder<'value>) : Decoder<(string * 'value) list> =
        fun path value ->
            match keys path value with
            | Ok objectKeys ->
                (Ok [], objectKeys) ||> List.fold (fun acc prop ->
                    match acc with
                    | Error _ -> acc
                    | Ok acc ->
                        match Helpers.getField prop value |> decoder path with
                        | Error er -> Error er
                        | Ok value -> (prop, value)::acc |> Ok)
                |> Result.map List.rev
            | Error e -> Error e

    //////////////////////////////
    // Inconsistent Structure ///
    ////////////////////////////

    let oneOf (decoders : Decoder<'value> list) : Decoder<'value> =
        fun path value ->
            let rec runner (decoders : Decoder<'value> list) (errors : string list) =
                match decoders with
                | head::tail ->
                    match fromValue path head value with
                    | Ok v ->
                        Ok v
                    | Error error -> runner tail (errors @ [error])
                | [] -> (path, BadOneOf errors) |> Error

            runner decoders []

    //////////////////////
    // Fancy decoding ///
    ////////////////////

    let nil (output : 'a) : Decoder<'a> =
        fun path value ->
            if Helpers.isNullValue value then
                Ok output
            else
                (path, BadPrimitive("null", value)) |> Error

    let value _ v = Ok v

    let succeed (output : 'a) : Decoder<'a> =
        fun _ _ ->
            Ok output

    let fail (msg: string) : Decoder<'a> =
        fun path _ ->
            (path, FailMessage msg) |> Error

    let andThen (cb: 'a -> Decoder<'b>) (decoder : Decoder<'a>) : Decoder<'b> =
        fun path value ->
            match decoder path value with
            | Error error -> Error error
            | Ok result -> cb result path value

    let all (decoders: Decoder<'a> list): Decoder<'a list> =
        fun path value ->
            let rec runner (decoders: Decoder<'a> list) (values: 'a list) =
                match decoders with
                | decoder :: tail ->
                    match decoder path value with
                    | Ok value -> runner tail (values @ [ value ])
                    | Error error -> Error error
                | [] -> Ok values

            runner decoders []

    /////////////////////
    // Map functions ///
    ///////////////////

    let map
        (ctor : 'a -> 'value)
        (d1 : Decoder<'a>) : Decoder<'value> =
        fun path value ->
            match d1 path value with
            | Ok v1 -> Ok (ctor v1)
            | Error er -> Error er

    let map2
        (ctor : 'a -> 'b -> 'value)
        (d1 : Decoder<'a>)
        (d2 : Decoder<'b>) : Decoder<'value> =
        fun path value ->
            match d1 path value, d2 path value with
            | Ok v1, Ok v2 -> Ok (ctor v1 v2)
            | Error er,_ -> Error er
            | _,Error er -> Error er

    let map3
        (ctor : 'a -> 'b -> 'c -> 'value)
        (d1 : Decoder<'a>)
        (d2 : Decoder<'b>)
        (d3 : Decoder<'c>) : Decoder<'value> =
        fun path value ->
            match d1 path value, d2 path value, d3 path value with
            | Ok v1, Ok v2, Ok v3 -> Ok (ctor v1 v2 v3)
            | Error er,_,_ -> Error er
            | _,Error er,_ -> Error er
            | _,_,Error er -> Error er

    let map4
        (ctor : 'a -> 'b -> 'c -> 'd -> 'value)
        (d1 : Decoder<'a>)
        (d2 : Decoder<'b>)
        (d3 : Decoder<'c>)
        (d4 : Decoder<'d>) : Decoder<'value> =
        fun path value ->
            match d1 path value, d2 path value, d3 path value, d4 path value with
            | Ok v1, Ok v2, Ok v3, Ok v4 -> Ok (ctor v1 v2 v3 v4)
            | Error er,_,_,_ -> Error er
            | _,Error er,_,_ -> Error er
            | _,_,Error er,_ -> Error er
            | _,_,_,Error er -> Error er

    let map5
        (ctor : 'a -> 'b -> 'c -> 'd -> 'e -> 'value)
        (d1 : Decoder<'a>)
        (d2 : Decoder<'b>)
        (d3 : Decoder<'c>)
        (d4 : Decoder<'d>)
        (d5 : Decoder<'e>) : Decoder<'value> =
        fun path value ->
            match d1 path value, d2 path value, d3 path value, d4 path value, d5 path value with
            | Ok v1, Ok v2, Ok v3, Ok v4, Ok v5 -> Ok (ctor v1 v2 v3 v4 v5)
            | Error er,_,_,_,_ -> Error er
            | _,Error er,_,_,_ -> Error er
            | _,_,Error er,_,_ -> Error er
            | _,_,_,Error er,_ -> Error er
            | _,_,_,_,Error er -> Error er

    let map6
        (ctor : 'a -> 'b -> 'c -> 'd -> 'e -> 'f -> 'value)
        (d1 : Decoder<'a>)
        (d2 : Decoder<'b>)
        (d3 : Decoder<'c>)
        (d4 : Decoder<'d>)
        (d5 : Decoder<'e>)
        (d6 : Decoder<'f>) : Decoder<'value> =
        fun path value ->
            match d1 path value, d2 path value, d3 path value, d4 path value, d5 path value, d6 path value with
            | Ok v1, Ok v2, Ok v3, Ok v4, Ok v5, Ok v6 -> Ok (ctor v1 v2 v3 v4 v5 v6)
            | Error er,_,_,_,_,_ -> Error er
            | _,Error er,_,_,_,_ -> Error er
            | _,_,Error er,_,_,_ -> Error er
            | _,_,_,Error er,_,_ -> Error er
            | _,_,_,_,Error er,_ -> Error er
            | _,_,_,_,_,Error er -> Error er

    let map7
        (ctor : 'a -> 'b -> 'c -> 'd -> 'e -> 'f -> 'g -> 'value)
        (d1 : Decoder<'a>)
        (d2 : Decoder<'b>)
        (d3 : Decoder<'c>)
        (d4 : Decoder<'d>)
        (d5 : Decoder<'e>)
        (d6 : Decoder<'f>)
        (d7 : Decoder<'g>) : Decoder<'value> =
        fun path value ->
            match d1 path value, d2 path value, d3 path value, d4 path value, d5 path value, d6 path value, d7 path value with
            | Ok v1, Ok v2, Ok v3, Ok v4, Ok v5, Ok v6, Ok v7 -> Ok (ctor v1 v2 v3 v4 v5 v6 v7)
            | Error er,_,_,_,_,_,_ -> Error er
            | _,Error er,_,_,_,_,_ -> Error er
            | _,_,Error er,_,_,_,_ -> Error er
            | _,_,_,Error er,_,_,_ -> Error er
            | _,_,_,_,Error er,_,_ -> Error er
            | _,_,_,_,_,Error er,_ -> Error er
            | _,_,_,_,_,_,Error er -> Error er

    let map8
        (ctor : 'a -> 'b -> 'c -> 'd -> 'e -> 'f -> 'g -> 'h -> 'value)
        (d1 : Decoder<'a>)
        (d2 : Decoder<'b>)
        (d3 : Decoder<'c>)
        (d4 : Decoder<'d>)
        (d5 : Decoder<'e>)
        (d6 : Decoder<'f>)
        (d7 : Decoder<'g>)
        (d8 : Decoder<'h>) : Decoder<'value> =
        fun path value ->
            match d1 path value, d2 path value, d3 path value, d4 path value, d5 path value, d6 path value, d7 path value, d8 path value with
            | Ok v1, Ok v2, Ok v3, Ok v4, Ok v5, Ok v6, Ok v7, Ok v8 -> Ok (ctor v1 v2 v3 v4 v5 v6 v7 v8)
            | Error er,_,_,_,_,_,_,_ -> Error er
            | _,Error er,_,_,_,_,_,_ -> Error er
            | _,_,Error er,_,_,_,_,_ -> Error er
            | _,_,_,Error er,_,_,_,_ -> Error er
            | _,_,_,_,Error er,_,_,_ -> Error er
            | _,_,_,_,_,Error er,_,_ -> Error er
            | _,_,_,_,_,_,Error er,_ -> Error er
            | _,_,_,_,_,_,_,Error er -> Error er

    let dict (decoder : Decoder<'value>) : Decoder<Map<string, 'value>> =
        map Map.ofList (keyValuePairs decoder)

    //////////////////////
    // Object builder ///
    ////////////////////

    type IRequiredGetter =
        abstract Field : string -> Decoder<'a> -> 'a
        abstract At : List<string> -> Decoder<'a> -> 'a
        abstract Raw : Decoder<'a> -> 'a

    type IOptionalGetter =
        abstract Field : string -> Decoder<'a> -> 'a option
        abstract At : List<string> -> Decoder<'a> -> 'a option
        abstract Raw : Decoder<'a> -> 'a option

    type IGetters =
        abstract Required: IRequiredGetter
        abstract Optional: IOptionalGetter

    let private unwrapWith (errors: ResizeArray<DecoderError>) path (decoder: Decoder<'T>) value: 'T =
        match decoder path value with
        | Ok v -> v
        | Error er -> errors.Add(er); Unchecked.defaultof<'T>

    type Getters<'T>(path: string, v: 'T) =
        let mutable errors = ResizeArray<DecoderError>()
        let required =
            { new IRequiredGetter with
                member __.Field (fieldName : string) (decoder : Decoder<_>) =
                    unwrapWith errors path (field fieldName decoder) v
                member __.At (fieldNames : string list) (decoder : Decoder<_>) =
                    unwrapWith errors path (at fieldNames decoder) v
                member __.Raw (decoder: Decoder<_>) =
                    unwrapWith errors path decoder v }
        let optional =
            { new IOptionalGetter with
                member __.Field (fieldName : string) (decoder : Decoder<_>) =
                    unwrapWith errors path (optional fieldName decoder) v
                member __.At (fieldNames : string list) (decoder : Decoder<_>) =
                    unwrapWith errors path (optionalAt fieldNames decoder) v
                member __.Raw (decoder: Decoder<_>) =
                    match decoder path v with
                    | Ok v -> Some v
                    | Error((_, reason) as error) ->
                        match reason with
                        | BadPrimitive(_,v)
                        | BadPrimitiveExtra(_,v,_)
                        | BadType(_,v) ->
                            if Helpers.isNullValue v then None
                            else errors.Add(error); Unchecked.defaultof<_>
                        | BadField _
                        | BadPath _ -> None
                        | TooSmallArray _
                        | FailMessage _
                        | BadOneOf _ -> errors.Add(error); Unchecked.defaultof<_> }
        member __.Errors: _ list = Seq.toList errors
        interface IGetters with
            member __.Required = required
            member __.Optional = optional

    let object (builder: IGetters -> 'value) : Decoder<'value> =
        fun path v ->
            let getters = Getters(path, v)
            let result = builder getters
            match getters.Errors with
            | [] -> Ok result
            | fst::_ as errors ->
                if errors.Length > 1 then
                    let errors = List.map errorToString errors
                    (path, BadOneOf errors) |> Error
                else
                    Error fst

    ///////////////////////
    // Tuples decoders ///
    ////////////////////

    let tuple2 (decoder1: Decoder<'T1>) (decoder2: Decoder<'T2>) : Decoder<'T1 * 'T2> =
        index 0 decoder1
        |> andThen (fun v1 ->
            index 1 decoder2
            |> andThen (fun v2 ->
                succeed (v1, v2)
            )
        )

    let tuple3 (decoder1: Decoder<'T1>)
               (decoder2: Decoder<'T2>)
               (decoder3: Decoder<'T3>) : Decoder<'T1 * 'T2 * 'T3> =
        index 0 decoder1
        |> andThen (fun v1 ->
            index 1 decoder2
            |> andThen (fun v2 ->
                index 2 decoder3
                |> andThen (fun v3 ->
                    succeed (v1, v2, v3)
                )
            )
        )

    let tuple4 (decoder1: Decoder<'T1>)
               (decoder2: Decoder<'T2>)
               (decoder3: Decoder<'T3>)
               (decoder4: Decoder<'T4>) : Decoder<'T1 * 'T2 * 'T3 * 'T4> =
        index 0 decoder1
        |> andThen (fun v1 ->
            index 1 decoder2
            |> andThen (fun v2 ->
                index 2 decoder3
                |> andThen (fun v3 ->
                    index 3 decoder4
                    |> andThen (fun v4 ->
                        succeed (v1, v2, v3, v4)
                    )
                )
            )
        )

    let tuple5 (decoder1: Decoder<'T1>)
               (decoder2: Decoder<'T2>)
               (decoder3: Decoder<'T3>)
               (decoder4: Decoder<'T4>)
               (decoder5: Decoder<'T5>) : Decoder<'T1 * 'T2 * 'T3 * 'T4 * 'T5> =
        index 0 decoder1
        |> andThen (fun v1 ->
            index 1 decoder2
            |> andThen (fun v2 ->
                index 2 decoder3
                |> andThen (fun v3 ->
                    index 3 decoder4
                    |> andThen (fun v4 ->
                        index 4 decoder5
                        |> andThen (fun v5 ->
                            succeed (v1, v2, v3, v4, v5)
                        )
                    )
                )
            )
        )

    let tuple6 (decoder1: Decoder<'T1>)
               (decoder2: Decoder<'T2>)
               (decoder3: Decoder<'T3>)
               (decoder4: Decoder<'T4>)
               (decoder5: Decoder<'T5>)
               (decoder6: Decoder<'T6>) : Decoder<'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6> =
        index 0 decoder1
        |> andThen (fun v1 ->
            index 1 decoder2
            |> andThen (fun v2 ->
                index 2 decoder3
                |> andThen (fun v3 ->
                    index 3 decoder4
                    |> andThen (fun v4 ->
                        index 4 decoder5
                        |> andThen (fun v5 ->
                            index 5 decoder6
                            |> andThen (fun v6 ->
                                succeed (v1, v2, v3, v4, v5, v6)
                            )
                        )
                    )
                )
            )
        )

    let tuple7 (decoder1: Decoder<'T1>)
               (decoder2: Decoder<'T2>)
               (decoder3: Decoder<'T3>)
               (decoder4: Decoder<'T4>)
               (decoder5: Decoder<'T5>)
               (decoder6: Decoder<'T6>)
               (decoder7: Decoder<'T7>) : Decoder<'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7> =
        index 0 decoder1
        |> andThen (fun v1 ->
            index 1 decoder2
            |> andThen (fun v2 ->
                index 2 decoder3
                |> andThen (fun v3 ->
                    index 3 decoder4
                    |> andThen (fun v4 ->
                        index 4 decoder5
                        |> andThen (fun v5 ->
                            index 5 decoder6
                            |> andThen (fun v6 ->
                                index 6 decoder7
                                |> andThen (fun v7 ->
                                    succeed (v1, v2, v3, v4, v5, v6, v7)
                                )
                            )
                        )
                    )
                )
            )
        )

    let tuple8 (decoder1: Decoder<'T1>)
               (decoder2: Decoder<'T2>)
               (decoder3: Decoder<'T3>)
               (decoder4: Decoder<'T4>)
               (decoder5: Decoder<'T5>)
               (decoder6: Decoder<'T6>)
               (decoder7: Decoder<'T7>)
               (decoder8: Decoder<'T8>) : Decoder<'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8> =
        index 0 decoder1
        |> andThen (fun v1 ->
            index 1 decoder2
            |> andThen (fun v2 ->
                index 2 decoder3
                |> andThen (fun v3 ->
                    index 3 decoder4
                    |> andThen (fun v4 ->
                        index 4 decoder5
                        |> andThen (fun v5 ->
                            index 5 decoder6
                            |> andThen (fun v6 ->
                                index 6 decoder7
                                |> andThen (fun v7 ->
                                    index 7 decoder8
                                    |> andThen (fun v8 ->
                                        succeed (v1, v2, v3, v4, v5, v6, v7, v8)
                                    )
                                )
                            )
                        )
                    )
                )
            )
        )

    ////////////
    // Enum ///
    /////////

    #if !FABLE_REPL_LIB
    module Enum =

        let inline byte<'TEnum when 'TEnum : enum<byte>> : Decoder<'TEnum> =
            byte
            |> andThen (fun value ->
                LanguagePrimitives.EnumOfValue<byte, 'TEnum> value
                |> succeed
            )

        let inline sbyte<'TEnum when 'TEnum : enum<sbyte>> : Decoder<'TEnum> =
            sbyte
            |> andThen (fun value ->
                LanguagePrimitives.EnumOfValue<sbyte, 'TEnum> value
                |> succeed
            )

        let inline int16<'TEnum when 'TEnum : enum<int16>> : Decoder<'TEnum> =
            int16
            |> andThen (fun value ->
                LanguagePrimitives.EnumOfValue<int16, 'TEnum> value
                |> succeed
            )

        let inline uint16<'TEnum when 'TEnum : enum<uint16>> : Decoder<'TEnum> =
            uint16
            |> andThen (fun value ->
                LanguagePrimitives.EnumOfValue<uint16, 'TEnum> value
                |> succeed
            )

        let inline int<'TEnum when 'TEnum : enum<int>> : Decoder<'TEnum> =
            int
            |> andThen (fun value ->
                LanguagePrimitives.EnumOfValue<int, 'TEnum> value
                |> succeed
            )

        let inline uint32<'TEnum when 'TEnum : enum<uint32>> : Decoder<'TEnum> =
            uint32
            |> andThen (fun value ->
                LanguagePrimitives.EnumOfValue<uint32, 'TEnum> value
                |> succeed
            )
    #endif

    //////////////////
    // Reflection ///
    ////////////////

    open FSharp.Reflection

    type private DecodeAutoExtra =
        { Decoders: Map<string, ref<BoxedDecoder>>
          FieldDecoders: Map<string, Map<string, FieldDecoder>>
          CaseStrategy: CaseStrategy }

    // As generics are erased by Fable, let's just do an unsafe cast for performance
    let inline boxDecoder (d: Decoder<'T>): BoxedDecoder =
        !!d // d >> Result.map box

    let inline unboxDecoder (d: BoxedDecoder): Decoder<'T> =
        !!d // d >> Result.map unbox

    // This is used to force Fable use a generic comparer for map keys
    let private toMap<'key, 'value when 'key: comparison> (xs: ('key*'value) seq) = Map.ofSeq xs
    let private toSet<'key when 'key: comparison> (xs: 'key seq) = Set.ofSeq xs

    let private toDict<'key, 'value when 'key: comparison> (xs: ('key*'value) seq) =
        let dic = System.Collections.Generic.Dictionary<'key, 'value>()
        for (k, v) in xs do dic.Add(k, v)
        dic

    let private toHashSet<'key when 'key: comparison> (xs: 'key seq) =
        let set = System.Collections.Generic.HashSet<'key>()
        for x in xs do set.Add(x) |> ignore
        set

    let private autoObject (decoderInfos: (string * BoxedDecoder)[]) (fieldDecoders: Map<string, FieldDecoder>) (path : string) (value: JsonValue) =
        if not (Helpers.isObject value) then
            (path, BadPrimitive ("an object", value)) |> Error
        else
            (decoderInfos, Ok []) ||> Array.foldBack (fun (name, decoder) acc ->
                match acc with
                | Error _ -> acc
                | Ok result ->
                    let path = path + "." + name
                    let value = Helpers.getField name value
                    match Map.tryFind name fieldDecoders with
                    | None -> decoder path value
                    | Some fieldDecoder ->
                        match fieldDecoder path (Option.ofObj value) with
                        | UseOk v -> Ok v
                        | UseError e -> Error e
                        | UseAutoDecoder -> decoder path value
                    |> Result.map (fun v -> v::result))

    let inline private enumDecoder<'UnderlineType when 'UnderlineType : equality>
        (decoder : Decoder<'UnderlineType>)
        (toString : 'UnderlineType -> string)
        (t: System.Type) =

            fun path value ->
                match decoder path value with
                | Ok enumValue ->
                    System.Enum.GetValues(t)
                    |> Seq.cast<'UnderlineType>
                    |> Seq.contains enumValue
                    |> function
                    | true ->
                        System.Enum.Parse(t, toString enumValue)
                        |> Ok
                    | false ->
                        (path, BadPrimitiveExtra(t.FullName, value, "Unknown value provided for the enum"))
                        |> Error
                | Error msg ->
                    Error msg

    let private autoObject2 (keyDecoder: BoxedDecoder) (valueDecoder: BoxedDecoder) (path : string) (value: JsonValue) =
        if not (Helpers.isObject value) then
            (path, BadPrimitive ("an object", value)) |> Error
        else
            (Ok [], Helpers.objectKeys(value)) ||> Seq.fold (fun acc name ->
                match acc with
                | Error _ -> acc
                | Ok acc ->
                    match keyDecoder path name with
                    | Error er -> Error er
                    | Ok k ->
                        Helpers.getField name value
                        |> valueDecoder (path + "." + name)
                        |> function
                            | Error er -> Error er
                            | Ok v -> (k,v)::acc |> Ok)

    let private mixedArray msg (decoders: BoxedDecoder[]) (path: string) (values: JsonValue[]): Result<JsonValue list, DecoderError> =
        if decoders.Length <> values.Length then
            (path, sprintf "Expected %i %s but got %i" decoders.Length msg values.Length
            |> FailMessage) |> Error
        else
            (values, decoders, Ok [])
            |||> Array.foldBack2 (fun value decoder acc ->
                match acc with
                | Error _ -> acc
                | Ok result -> decoder path value |> Result.map (fun v -> v::result))

    let rec private makeUnion extra t name (path : string) (values: JsonValue[]) =
        let uci =
            FSharpType.GetUnionCases(t, allowAccessToPrivateRepresentation=true)
            |> Array.tryFind (fun x -> x.Name = name)
        match uci with
        | None -> (path, FailMessage("Cannot find case " + name + " in " + t.FullName)) |> Error
        | Some uci ->
            if values.Length = 0 then
                FSharpValue.MakeUnion(uci, [||], allowAccessToPrivateRepresentation=true) |> Ok
            else
                let decoders = uci.GetFields() |> Array.map (fun fi -> autoDecoder extra false fi.PropertyType)
                mixedArray "union fields" decoders path values
                |> Result.map (fun values -> FSharpValue.MakeUnion(uci, List.toArray values, allowAccessToPrivateRepresentation=true))

    and private autoDecodeRecordsAndUnions (extra: DecodeAutoExtra) (isOptional : bool) (t: System.Type) : BoxedDecoder =
        // Add the decoder to extra in case one of the fields is recursive
        let decoderRef = ref Unchecked.defaultof<_>
        let extra = { extra with Decoders = extra.Decoders |> Map.add t.FullName decoderRef }
        let decoder =
            if FSharpType.IsRecord(t, allowAccessToPrivateRepresentation=true) then
                let fieldDecoders =
                    Map.tryFind t.FullName extra.FieldDecoders
                    |> Option.defaultValue Map.empty
                let decoders =
                    FSharpType.GetRecordFields(t, allowAccessToPrivateRepresentation=true)
                    |> Array.map (fun fi ->
                        let name = Util.Casing.convert extra.CaseStrategy fi.Name
                        name, autoDecoder extra false fi.PropertyType)
                fun path value ->
                    autoObject decoders fieldDecoders path value
                    |> Result.map (fun xs -> FSharpValue.MakeRecord(t, List.toArray xs, allowAccessToPrivateRepresentation=true))

            elif FSharpType.IsUnion(t, allowAccessToPrivateRepresentation=true) then
                fun path (value: JsonValue) ->
                    if Helpers.isString(value) then
                        let name = Helpers.asString value
                        makeUnion extra t name path [||]
                    elif Helpers.isArray(value) then
                        let values = Helpers.asArray value
                        let name = Helpers.asString values.[0]
                        makeUnion extra t name path values.[1..]
                    else (path, BadPrimitive("a string or array", value)) |> Error

            else
                if isOptional then
                    // The error will only happen at runtime if the value is not null
                    // See https://github.com/MangelMaxime/Thoth/pull/84#issuecomment-444837773
                    boxDecoder(fun path value -> Error(path, BadType("an extra coder for " + t.FullName, value)))
                else
                    // Don't use failwithf here, for some reason F#/Fable compiles it as a function
                    // when the return type is a function too, so it doesn't fail immediately
                    sprintf "Cannot generate auto decoder for %s. Please pass an extra decoder." t.FullName |> failwith
        decoderRef := decoder
        decoder

    and private autoDecodeMapOrDict constructor (extra: DecodeAutoExtra) (t: System.Type) : BoxedDecoder =
        let keyDecoder = t.GenericTypeArguments.[0] |> autoDecoder extra false
        let valueDecoder = t.GenericTypeArguments.[1] |> autoDecoder extra false
        oneOf [
            autoObject2 keyDecoder valueDecoder
            list (tuple2 keyDecoder valueDecoder)
        ] |> map constructor

    and private autoDecodeSetOrHashset constructor (extra: DecodeAutoExtra) (t: System.Type) : BoxedDecoder =
        let decoder = t.GenericTypeArguments.[0] |> autoDecoder extra false
        fun path value ->
            match array decoder path value with
            | Error er -> Error er
            | Ok ar -> constructor ar |> Ok

    and private autoDecoder (extra: DecodeAutoExtra) (isOptional : bool) (t: System.Type) : BoxedDecoder =
      let fullname = t.FullName
      match Map.tryFind fullname extra.Decoders with
      | Some decoderRef -> fun path value -> decoderRef.contents path value
      | None ->
        if t.IsArray then
            let decoder = t.GetElementType() |> autoDecoder extra false
            array decoder |> boxDecoder
        elif t.IsEnum then
            let enumType = System.Enum.GetUnderlyingType(t).FullName
            if enumType = typeof<sbyte>.FullName then
                enumDecoder<sbyte> sbyte Operators.string t |> boxDecoder
            elif enumType = typeof<byte>.FullName then
                enumDecoder<byte> byte Operators.string t |> boxDecoder
            elif enumType = typeof<int16>.FullName then
                enumDecoder<int16> int16 Operators.string t |> boxDecoder
            elif enumType = typeof<uint16>.FullName then
                enumDecoder<uint16> uint16 Operators.string t |> boxDecoder
            elif enumType = typeof<int>.FullName then
                enumDecoder<int> int Operators.string t |> boxDecoder
            elif enumType = typeof<uint32>.FullName then
                enumDecoder<uint32> uint32 Operators.string t |> boxDecoder
            else
                failwithf
                    """Cannot generate auto decoder for %s.
    Thoth.Json.Net only support the following enum types:
    - sbyte
    - byte
    - int16
    - uint16
    - int
    - uint32
    If you can't use one of these types, please pass an extra decoder.
                    """ t.FullName
        elif t.IsGenericType then
            if FSharpType.IsTuple(t) then
                let decoders = FSharpType.GetTupleElements(t) |> Array.map (autoDecoder extra false)
                fun path value ->
                    if Helpers.isArray value then
                        mixedArray "tuple elements" decoders path (Helpers.asArray value)
                        |> Result.map (fun xs -> FSharpValue.MakeTuple(List.toArray xs, t))
                    else (path, BadPrimitive ("an array", value)) |> Error
            else
                let fullname = t.GetGenericTypeDefinition().FullName
                if fullname = typedefof<obj option>.FullName then
                    t.GenericTypeArguments.[0] |> (autoDecoder extra true) |> option |> boxDecoder
                elif fullname = typedefof<obj list>.FullName then
                    t.GenericTypeArguments.[0] |> (autoDecoder extra false) |> list |> boxDecoder
                elif fullname = typedefof<obj seq>.FullName then
                    t.GenericTypeArguments.[0] |> (autoDecoder extra false) |> seq |> boxDecoder
                elif fullname = typedefof< Map<string, obj> >.FullName then
                    autoDecodeMapOrDict (fun ar -> toMap (unbox ar) |> box) extra t
                elif fullname = typedefof< System.Collections.Generic.Dictionary<string, obj> >.FullName then
                    autoDecodeMapOrDict (fun ar ->
                        // For generic keys, Fable creates a structure with a custom equality comparer.
                        // Deal with string keys separately to let Fable generate native JS Maps
                        if t.GenericTypeArguments.[0].FullName = typeof<string>.FullName then
                            let dic = System.Collections.Generic.Dictionary<string, obj>()
                            for (k, v) in (unbox ar) do dic.Add(k, v)
                            box dic
                        else
                            toDict (unbox ar) |> box) extra t
                elif fullname = typedefof< Set<string> >.FullName then
                    autoDecodeSetOrHashset (fun ar -> toSet (unbox ar) |> box) extra t
                elif fullname = typedefof< System.Collections.Generic.HashSet<string> >.FullName then
                    autoDecodeSetOrHashset (fun ar -> toHashSet (unbox ar) |> box) extra t
                else
                    autoDecodeRecordsAndUnions extra isOptional t
        else
            if fullname = typeof<bool>.FullName then
                boxDecoder bool
            elif fullname = typedefof<unit>.FullName then
                boxDecoder unit
            elif fullname = typeof<string>.FullName then
                boxDecoder string
            elif fullname = typeof<sbyte>.FullName then
                boxDecoder sbyte
            elif fullname = typeof<byte>.FullName then
                boxDecoder byte
            elif fullname = typeof<int16>.FullName then
                boxDecoder int16
            elif fullname = typeof<uint16>.FullName then
                boxDecoder uint16
            elif fullname = typeof<int>.FullName then
                boxDecoder int
            elif fullname = typeof<uint32>.FullName then
                boxDecoder uint32
            elif fullname = typeof<float>.FullName then
                boxDecoder float
            elif fullname = typeof<float32>.FullName then
                boxDecoder float32
            // These number types require extra libraries in Fable. To prevent penalizing
            // all users, extra decoders (withInt64, etc) must be passed when they're needed.

            // elif fullname = typeof<int64>.FullName then
            //     boxDecoder int64
            // elif fullname = typeof<uint64>.FullName then
            //     boxDecoder uint64
            // elif fullname = typeof<bigint>.FullName then
            //     boxDecoder bigint
            // elif fullname = typeof<decimal>.FullName then
            //     boxDecoder decimal
            elif fullname = typeof<System.DateTime>.FullName then
                boxDecoder datetime
            elif fullname = typeof<System.DateTimeOffset>.FullName then
                boxDecoder datetimeOffset
            elif fullname = typeof<System.TimeSpan>.FullName then
                boxDecoder timespan
            elif fullname = typeof<System.Guid>.FullName then
                boxDecoder guid
            elif fullname = typeof<obj>.FullName then
                fun _ v -> Ok v
            else autoDecodeRecordsAndUnions extra isOptional t

    let private makeExtra (extra: ExtraCoders option) caseStrategy =
        let decoders =
            extra |> Option.map (fun e -> e.Coders |> Map.map (fun _ (_,dec) -> ref dec))
        let fieldDecoders =
            extra |> Option.map (fun e ->
                e.FieldDecoders |> Map.map (fun _ kvs ->
                    kvs |> Seq.map (fun kv -> Util.Casing.convert caseStrategy kv.Key, kv.Value) |> Map))
        {
            CaseStrategy = caseStrategy
            Decoders = defaultArg decoders Map.empty
            FieldDecoders = defaultArg fieldDecoders Map.empty
        }

    type Auto =
        static member generateDecoderCached<'T>(?caseStrategy : CaseStrategy, ?extra: ExtraCoders, [<Inject>] ?resolver: ITypeResolver<'T>): Decoder<'T> =
            let t = Util.resolveType resolver
            let caseStrategy = defaultArg caseStrategy PascalCase

            let key =
                t.FullName
                |> (+) (Operators.string caseStrategy)
                |> (+) (extra |> Option.map (fun e -> e.Hash) |> Option.defaultValue "")

            Util.CachedDecoders.GetOrAdd(key, fun _ ->
                autoDecoder (makeExtra extra caseStrategy) false t) |> unboxDecoder

        static member generateDecoder<'T>(?caseStrategy : CaseStrategy, ?extra: ExtraCoders, [<Inject>] ?resolver: ITypeResolver<'T>): Decoder<'T> =
            let caseStrategy = defaultArg caseStrategy PascalCase
            Util.resolveType resolver
            |> autoDecoder (makeExtra extra caseStrategy) false |> unboxDecoder

        static member fromString<'T>(json: string, ?caseStrategy : CaseStrategy, ?extra: ExtraCoders, [<Inject>] ?resolver: ITypeResolver<'T>): Result<'T, string> =
            let decoder = Auto.generateDecoder(?caseStrategy=caseStrategy, ?extra=extra, ?resolver=resolver)
            fromString decoder json

        static member unsafeFromString<'T>(json: string, ?caseStrategy : CaseStrategy, ?extra: ExtraCoders, [<Inject>] ?resolver: ITypeResolver<'T>): 'T =
            let decoder = Auto.generateDecoder(?caseStrategy=caseStrategy, ?extra=extra, ?resolver=resolver)
            match fromString decoder json with
            | Ok x -> x
            | Error msg -> failwith msg