[
    {
        "name": "Either",
        "comment": "\nA generic structure for a type with two possibilities: a `Left a` or\na `Right b`.\n\nAn `Either` is right-biased, so most operations will be applied to\nthe `Right`.\n\nThis is similar to `Result` type in `core`, but is more generic.\nIf your looking for a data type to do error handling, you should\nuse `Result` instead.\n\n\n# Definition\n@docs Either\n\n# Mapping\n@docs map, map2, map3, mapLeft, mapRight, mapBoth, mapDefault\n\n# Singleton & Applying\n@docs singleton, andMap\n\n# Chaining\n@docs andThen\n\n# List Helpers\n@docs lefts, rights, partition\n\n# Maybe Helpers\n@docs toMaybe, leftToMaybe, rightToMaybe, fromMaybe, leftFromMaybe, rightFromMaybe\n\n# Result Helpers\n@docs toResult, fromResult\n\n# Rest of the Helpers\n@docs isLeft, isRight, fromLeft, fromRight, withDefault, elim, either, swap\n",
        "unions": [
            {
                "name": "Either",
                "comment": " ",
                "args": [
                    "a",
                    "b"
                ],
                "cases": [
                    [
                        "Left",
                        [
                            "a"
                        ]
                    ],
                    [
                        "Right",
                        [
                            "b"
                        ]
                    ]
                ]
            }
        ],
        "aliases": [],
        "values": [
            {
                "name": "andMap",
                "comment": " Apply the function that is inside `Either` to a value that is inside\n`Either`. Return the result inside `Either`. If one of the `Either`\narguments is `Left x`, return `Left x`. Also known as `apply`.\n",
                "type": "Either x (a -> b) -> Either x a -> Either x b"
            },
            {
                "name": "andThen",
                "comment": " Chain together in many computations that will stop computing if\na chain is on a `Left`. Also known as `bind`.\n",
                "type": "Either x a -> (a -> Either x b) -> Either x b"
            },
            {
                "name": "either",
                "comment": " Alias for `elim`.\n",
                "type": "(a -> c) -> (b -> c) -> Either a b -> c"
            },
            {
                "name": "elim",
                "comment": " Given a function for both `Left` and `Right` to to type a generic\ntype `c`, collapse down the `Either` to a value of that type.\n",
                "type": "(a -> c) -> (b -> c) -> Either a b -> c"
            },
            {
                "name": "fromLeft",
                "comment": " Extract left value or a default.\n",
                "type": "a -> Either a b -> a"
            },
            {
                "name": "fromMaybe",
                "comment": " Convert from a `Maybe` to `Either` with a default value\nfor `Left` for `Nothing`.\n",
                "type": "a -> Maybe b -> Either a b"
            },
            {
                "name": "fromResult",
                "comment": " Convert from `Result` to `Either`.\n",
                "type": "Result a b -> Either a b"
            },
            {
                "name": "fromRight",
                "comment": " Extract right value or a default.\n",
                "type": "b -> Either a b -> b"
            },
            {
                "name": "isLeft",
                "comment": " Returns `True` if argument is `Left _`\n",
                "type": "Either a b -> Bool"
            },
            {
                "name": "isRight",
                "comment": " Returns `True` if argument is `Right _`\n",
                "type": "Either a b -> Bool"
            },
            {
                "name": "leftFromMaybe",
                "comment": " Convert from a `Maybe` to `Either` with a default value\nfor `Right` for `Nothing`.\n",
                "type": "b -> Maybe a -> Either a b"
            },
            {
                "name": "leftToMaybe",
                "comment": " `Maybe` get the `Left` side of an `Either`.\n",
                "type": "Either a x -> Maybe a"
            },
            {
                "name": "lefts",
                "comment": " Converts a `List` of `Either a x` to a List of `a`.\n",
                "type": "List (Either a x) -> List a"
            },
            {
                "name": "map",
                "comment": " Apply a function to an `Either`. If the argument is `Right`, it\nwill be converted.  If the argument is an `Left`, the same left value\nwill propogate through.\n",
                "type": "(a -> b) -> Either x a -> Either x b"
            },
            {
                "name": "map2",
                "comment": " Apply a function to two eithers, if both arguments are `Right`.\nIf not, the first argument which is a `Left` will propagate through.\nAlso known as `liftA2`.\n",
                "type": "(a -> b -> c) -> Either x a -> Either x b -> Either x c"
            },
            {
                "name": "map3",
                "comment": " Like `map2`, but with 3 eithers. Also known as `liftA3`\n",
                "type": "(a -> b -> c -> d) -> Either x a -> Either x b -> Either x c -> Either x d"
            },
            {
                "name": "mapBoth",
                "comment": " Apply the first argument function to a `Left` and the second\nargument function to a `Right` of an `Either`.\n",
                "type": "(a -> b) -> (c -> d) -> Either a c -> Either b d"
            },
            {
                "name": "mapDefault",
                "comment": " Apply a function to `Right` value. If argument was a `Left` use the\ndefault value. Equivalent to `Either.map >> Either.fromRight`.\n",
                "type": "c -> (b -> c) -> Either x b -> c"
            },
            {
                "name": "mapLeft",
                "comment": " Apply a function to the `Left` of an `Either`.\n",
                "type": "(a -> b) -> Either a x -> Either b x"
            },
            {
                "name": "mapRight",
                "comment": " Alias for `map`.\n",
                "type": "(a -> b) -> Either x a -> Either x b"
            },
            {
                "name": "partition",
                "comment": " Converts a `List` of `Either a b`, into a tuple2 where\nthe first value is a `List a` and the second is `List b`.\n",
                "type": "List (Either a b) -> ( List a, List b )"
            },
            {
                "name": "rightFromMaybe",
                "comment": " Alias for `fromMaybe`.\n",
                "type": "a -> Maybe b -> Either a b"
            },
            {
                "name": "rightToMaybe",
                "comment": " Alias for `toMaybe`.\n",
                "type": "Either x b -> Maybe b"
            },
            {
                "name": "rights",
                "comment": " Converts a `List` of `Either x b` to a List of `b`.\n",
                "type": "List (Either x b) -> List b"
            },
            {
                "name": "singleton",
                "comment": " Create a `singleton` from a value to an `Either` with a `Right`\nof the same type.  Also known as `pure`.\n",
                "type": "b -> Either x b"
            },
            {
                "name": "swap",
                "comment": " Swap the `Left` and `Right` sides of an `Either`.\n",
                "type": "Either a b -> Either b a"
            },
            {
                "name": "toMaybe",
                "comment": " `Maybe` get the `Right` side of an `Either`.\n",
                "type": "Either x b -> Maybe b"
            },
            {
                "name": "toResult",
                "comment": " Convert from `Either` to `Result`.\n",
                "type": "Either a b -> Result a b"
            },
            {
                "name": "withDefault",
                "comment": " Alias for `fromRight`\n",
                "type": "b -> Either a b -> b"
            }
        ],
        "binops": []
    }
]