[
    {
        "name": "Shrink",
        "comment": "Library containing a collection of basic shrinking strategies and\nhelper functions to help you construct shrinking strategies.\n\n# Shinker\n@docs Shrinker\n\n# Shrinkers\n@docs noShrink, void, bool, order, int, atLeastInt, float, atLeastFloat, char, atLeastChar, character, string, maybe, result, lazylist, list, array, tuple, tuple3, tuple4, tuple5\n\n# Useful functions\n@docs convert, keepIf, dropIf, merge, map, andMap",
        "unions": [],
        "aliases": [
            {
                "name": "Shrinker",
                "comment": "Shrinker type.\nA shrinker is a function that takes a value and returns a list of values that\nare in some sense \"smaller\" than the given value. If there are no such values\nconceptually, then the shrinker should just return the empty list.",
                "args": [
                    "a"
                ],
                "type": "a -> LazyList a"
            }
        ],
        "values": [
            {
                "name": "andMap",
                "comment": "Apply a lazy list of functions on a lazy list of values.\n    andMap = Lazy.List.map2 (<|)\nThis is useful in order to compose shrinkers, especially when used in\nconjunction with `andMap`.",
                "type": "LazyList (a -> b) -> LazyList a -> LazyList b"
            },
            {
                "name": "array",
                "comment": "Array shrinker constructor.\nTakes a shrinker of values and returns a shrinker of Arrays.",
                "type": "Shrinker a -> Shrinker (Array a)"
            },
            {
                "name": "atLeastChar",
                "comment": "Construct a shrinker of chars which considers the given char to\nbe most minimal.",
                "type": "Char -> Shrinker Char"
            },
            {
                "name": "atLeastFloat",
                "comment": "Construct a shrinker of floats which considers the given float to\nbe most minimal.",
                "type": "Float -> Shrinker Float"
            },
            {
                "name": "atLeastInt",
                "comment": "Construct a shrinker of ints which considers the given int to\nbe most minimal.",
                "type": "Int -> Shrinker Int"
            },
            {
                "name": "bool",
                "comment": "Shrinker of bools.",
                "type": "Shrinker Bool"
            },
            {
                "name": "char",
                "comment": "Shrinker of chars.",
                "type": "Shrinker Char"
            },
            {
                "name": "character",
                "comment": "Shrinker of chars which considers the empty space as the most\nminimal char and omits the control key codes.\n\nEquivalent to:\n\n    atLeastChar (Char.fromCode 32)",
                "type": "Shrinker Char"
            },
            {
                "name": "convert",
                "comment": "Convert a Shrinker of a's into a Shrinker of b's using two inverse functions.\n\nIf you use this function as follows:\n\n    shrinkerB = f g shrinkerA\n\nMake sure that\n\n    `f(g(x)) == x` for all x\n\nOr else this process will generate garbage.",
                "type": "(a -> b) -> (b -> a) -> Shrinker a -> Shrinker b"
            },
            {
                "name": "dropIf",
                "comment": "Filter out the results of a shrinker. The resulting shrinker\nwill only throw away shrinks which satisfy the given predicate.",
                "type": "(a -> Bool) -> Shrinker a -> Shrinker a"
            },
            {
                "name": "float",
                "comment": "Shrinker of floats.",
                "type": "Shrinker Float"
            },
            {
                "name": "int",
                "comment": "Shrinker of integers.",
                "type": "Shrinker Int"
            },
            {
                "name": "keepIf",
                "comment": "Filter out the results of a shrinker. The resulting shrinker\nwill only produce shrinks which satisfy the given predicate.",
                "type": "(a -> Bool) -> Shrinker a -> Shrinker a"
            },
            {
                "name": "lazylist",
                "comment": "Lazy List shrinker constructor. (must be finite)\nTakes a shrinker of values and returns a shrinker of Lazy Lists.",
                "type": "Shrinker a -> Shrinker (LazyList a)"
            },
            {
                "name": "list",
                "comment": "List shrinker constructor.\nTakes a shrinker of values and returns a shrinker of Lists.",
                "type": "Shrinker a -> Shrinker (List a)"
            },
            {
                "name": "map",
                "comment": "Re-export of `Lazy.List.map`\nThis is useful in order to compose shrinkers, especially when used in\nconjunction with `andMap`.\nExample:\n    type alias Vector =\n      { x : Float\n      , y : Float\n      , z : Float\n      }\n    vector : Shrinker Float\n    vector {x,y,z} =\n      Vector\n        `map`    float x\n        `andMap` float y\n        `andMap` float z",
                "type": "(a -> b) -> LazyList a -> LazyList b"
            },
            {
                "name": "maybe",
                "comment": "Maybe shrinker constructor.\nTakes a shrinker of values and returns a shrinker of Maybes.",
                "type": "Shrinker a -> Shrinker (Maybe a)"
            },
            {
                "name": "merge",
                "comment": "Merge two shrinkers.",
                "type": "Shrinker a -> Shrinker a -> Shrinker a"
            },
            {
                "name": "noShrink",
                "comment": "Empty shrinker. Always returns the empty list.",
                "type": "Shrinker a"
            },
            {
                "name": "order",
                "comment": "Shrinker of Order.",
                "type": "Shrinker Order"
            },
            {
                "name": "result",
                "comment": "Result shrinker constructor.\nTakes a shrinker of errors and a shrinker of values and returns a shrinker\nof Results.",
                "type": "Shrinker error -> Shrinker value -> Shrinker (Result error value)"
            },
            {
                "name": "string",
                "comment": "Shrinker of strings. Considers the empty string to be the most\nminimal string and the space to be the most minimal char.\n\nEquivalent to:\n\n    convert String.fromList String.toList (list character)",
                "type": "Shrinker String"
            },
            {
                "name": "tuple",
                "comment": "2-Tuple shrinker constructor.\nTakes a tuple of shrinkers and returns a shrinker of tuples.",
                "type": "( Shrinker a, Shrinker b ) -> Shrinker ( a, b )"
            },
            {
                "name": "tuple3",
                "comment": "3-Tuple shrinker constructor.\nTakes a tuple of shrinkers and returns a shrinker of tuples.",
                "type": "( Shrinker a, Shrinker b, Shrinker c ) -> Shrinker ( a, b, c )"
            },
            {
                "name": "tuple4",
                "comment": "4-Tuple shrinker constructor.\nTakes a tuple of shrinkers and returns a shrinker of tuples.",
                "type": "( Shrinker a, Shrinker b, Shrinker c, Shrinker d ) -> Shrinker ( a, b, c, d )"
            },
            {
                "name": "tuple5",
                "comment": "5-Tuple shrinker constructor.\nTakes a tuple of shrinkers and returns a shrinker of tuples.",
                "type": "( Shrinker a, Shrinker b, Shrinker c, Shrinker d, Shrinker e ) -> Shrinker ( a, b, c, d, e )"
            },
            {
                "name": "void",
                "comment": "Shrink the empty tuple. Equivalent to `noShrink`.",
                "type": "Shrinker ()"
            }
        ],
        "binops": []
    }
]