[
    {
        "name": "Check.Test",
        "comment": "Submodule providing integration with elm-test.\n\n# Generate unit tests\n@docs test, assert\n\n# Multi-arity\n@docs test2, test3, test4, test5, assert2, assert3, assert4, assert5",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "assert",
                "comment": "Assert that a given predicate always yields true for a given investigator.\nAnalogous to `claimTrue`.",
                "type": "String -> (a -> Bool) -> Investigator a -> Int -> Seed -> Test"
            },
            {
                "name": "assert2",
                "comment": "",
                "type": "String -> (a -> b -> Bool) -> Investigator a -> Investigator b -> Int -> Seed -> Test"
            },
            {
                "name": "assert3",
                "comment": "",
                "type": "String -> (a -> b -> c -> Bool) -> Investigator a -> Investigator b -> Investigator c -> Int -> Seed -> Test"
            },
            {
                "name": "assert4",
                "comment": "",
                "type": "String -> (a -> b -> c -> d -> Bool) -> Investigator a -> Investigator b -> Investigator c -> Investigator d -> Int -> Seed -> Test"
            },
            {
                "name": "assert5",
                "comment": "",
                "type": "String -> (a -> b -> c -> d -> e -> Bool) -> Investigator a -> Investigator b -> Investigator c -> Investigator d -> Investigator e -> Int -> Seed -> Test"
            },
            {
                "name": "test",
                "comment": "Analogous to `claim`. Will generate a given number of unit tests for given\nactual and expected statements. If a unit tests fails, `test` will also generate\nan additional test representing a minimal input using shrinking.",
                "type": "String -> (a -> b) -> (a -> b) -> Investigator a -> Int -> Seed -> Test"
            },
            {
                "name": "test2",
                "comment": "",
                "type": "String -> (a -> b -> c) -> (a -> b -> c) -> Investigator a -> Investigator b -> Int -> Seed -> Test"
            },
            {
                "name": "test3",
                "comment": "",
                "type": "String -> (a -> b -> c -> d) -> (a -> b -> c -> d) -> Investigator a -> Investigator b -> Investigator c -> Int -> Seed -> Test"
            },
            {
                "name": "test4",
                "comment": "",
                "type": "String -> (a -> b -> c -> d -> e) -> (a -> b -> c -> d -> e) -> Investigator a -> Investigator b -> Investigator c -> Investigator d -> Int -> Seed -> Test"
            },
            {
                "name": "test5",
                "comment": "",
                "type": "String -> (a -> b -> c -> d -> e -> f) -> (a -> b -> c -> d -> e -> f) -> Investigator a -> Investigator b -> Investigator c -> Investigator d -> Investigator e -> Int -> Seed -> Test"
            }
        ],
        "binops": []
    },
    {
        "name": "Check",
        "comment": "Property Based Testing module in Elm.\n\n# Make a claim\n@docs claim, claimTrue, claimFalse\n\n# Check a claim\n@docs quickCheck, check\n\n# Group claims into a suite\n@docs suite\n\n# Types\n@docs Claim, Evidence, UnitEvidence, SuccessOptions, FailureOptions\n\n# Multi-arity claims\n@docs claim2, claim2True, claim2False, claim3, claim3True, claim3False, claim4, claim4True, claim4False, claim5, claim5True, claim5False\n\n# DSL\n\n`elm-check` provides a shorthand DSL for authoring claims. The goal of this\nDSL is to help improve readability and encode intent in the phrasing of your\ntest code.\n\nWith the DSL, claims read as either:\n\n1. claim - (string) - that - (actual) - is - (expected) - for - (investigator)\n2. claim - (string) - true - (predicate) - for - (investigator)\n3. claim - (string) - false - (predicate) - for - (investigator)\n\n\n**Example:**\n\n    claim_multiplication_by_one_noop =\n      claim\n        \"Multiplying by one does not change a number\"\n      `true`\n        (\\n -> n * 1 == n)\n      `for`\n        int\n\n    claim_reverse_append =\n      claim\n        \"Append then reverse is equivalent to reverse then append\"\n      `that`\n        (\\(l1, l2) -> List.reverse (l1 ++ l2))\n      `is`\n        (\\(l1, l2) -> List.reverse l1 ++ List.reverse l2)\n      `for`\n        tuple (list int, list int)\n\n\nIt is important to note that, if you wish to deal with multi-arity functions\nusing this DSL, you must deal explicitly in tuples.\n\n*Warning: The DSL follows a very strict format. Deviating from this format will\nyield potentially unintelligible type errors. While not all of the type errors\nare strictly necessary, they are there to ensure that the test is authored in\na uniform way. As a result, the following functions have horrendous type\nsignatures and you are better off ignoring them.*\n\n@docs that, is, for, true, false",
        "unions": [
            {
                "name": "Claim",
                "comment": "A Claim is an object that makes a claim of truth about a system.\nA claim is either a function which yields evidence regarding the claim\nor a list of such claims.",
                "args": [],
                "cases": [
                    [
                        "Claim",
                        [
                            "String",
                            "Int -> Seed -> Evidence"
                        ]
                    ],
                    [
                        "Suite",
                        [
                            "String",
                            "List Claim"
                        ]
                    ]
                ]
            },
            {
                "name": "Evidence",
                "comment": "Evidence is the output from checking a claim or multiple claims.",
                "args": [],
                "cases": [
                    [
                        "Unit",
                        [
                            "UnitEvidence"
                        ]
                    ],
                    [
                        "Multiple",
                        [
                            "String",
                            "List Evidence"
                        ]
                    ]
                ]
            }
        ],
        "aliases": [
            {
                "name": "FailureOptions",
                "comment": "FailureOptions is the concrete type returned in case evidence was found\ndisproving a Claim.\n\nFailureOptions contains:\n1. the `name` of the claim\n2. the minimal `counterExample` which serves as evidence that the claim is false\n3. the value `expected` to be returned by the claim\n4. the `actual` value returned by the claim\n5. the `seed` used in order to reproduce the results\n6. the number of checks performed\n7. the number of shrinking operations performed\n8. the original `counterExample`, `actual`, and `expected` values found prior\nto performing the shrinking operations.",
                "args": [],
                "type": "{ name : String, counterExample : String, actual : String, expected : String, original : { counterExample : String, actual : String, expected : String }, seed : Seed, numberOfChecks : Int, numberOfShrinks : Int }"
            },
            {
                "name": "SuccessOptions",
                "comment": "SuccessOptions is the concrete type returned in case there is no evidence\nfound disproving a Claim.\n\nSuccessOptions contains:\n1. the `name` of the claim\n2. the number of checks performed\n3. the `seed` used in order to reproduce the check.",
                "args": [],
                "type": "{ name : String, seed : Seed, numberOfChecks : Int }"
            },
            {
                "name": "UnitEvidence",
                "comment": "UnitEvidence is the concrete type returned by checking a single claim.\nA UnitEvidence can easily be converted to an assertion or can be considered\nas the result of an assertion.",
                "args": [],
                "type": "Result FailureOptions SuccessOptions"
            }
        ],
        "values": [
            {
                "name": "check",
                "comment": "Check a claim.\n\nTo check a claim, you need to provide the number of checks which check will\nperform as well a random seed. Given a random seed and a number of checks,\n`check` will always yield the same result. Thus, `check` is especially useful\nwhen you wish to reproduce checks.\n\n    check claim 100 (Random.initialSeed 1)",
                "type": "Claim -> Int -> Seed -> Evidence"
            },
            {
                "name": "claim",
                "comment": "Make a claim about a system.\n\n    claim nameOfClaim actualStatement expectedStatement investigator\n\n1. The `nameOfClaim` is a string you pass in order to name your claim.\nThis is very useful when trying to debug or reading reports.\n2. The `actualStatement` is a function which states something about your\nsystem. The result of which will be compared by equality `==` to the\nresult of the `expectedStatement`.\n3. The `expectedStatement` is a function which states something which\nthe `actualStatement` should conform to or be equivalent to. The result of\nwhich will be compared by equality `==` to the result of the `actualStatement`.\n4. The `investigator` is an investigator used to generate random values to be passed\nto the `actualStatement` and `expectedStatement` in order to attempt to\ndisprove the claim. If a counter example is found, the `investigator` will then\nshrink the counter example until it yields a minimal counter example which\nis then easy to debug.\n\n\nExample :\n\n    claim_sort_idempotent =\n      claim \"Sort is idempotent\"\n        (\\list -> List.sort (List.sort (list))\n        (\\list -> List.sort (list))\n        (list int)",
                "type": "String -> (a -> b) -> (a -> b) -> Investigator a -> Claim"
            },
            {
                "name": "claim2",
                "comment": "",
                "type": "String -> (a -> b -> c) -> (a -> b -> c) -> Investigator a -> Investigator b -> Claim"
            },
            {
                "name": "claim2False",
                "comment": "",
                "type": "String -> (a -> b -> Bool) -> Investigator a -> Investigator b -> Claim"
            },
            {
                "name": "claim2True",
                "comment": "",
                "type": "String -> (a -> b -> Bool) -> Investigator a -> Investigator b -> Claim"
            },
            {
                "name": "claim3",
                "comment": "",
                "type": "String -> (a -> b -> c -> d) -> (a -> b -> c -> d) -> Investigator a -> Investigator b -> Investigator c -> Claim"
            },
            {
                "name": "claim3False",
                "comment": "",
                "type": "String -> (a -> b -> c -> Bool) -> Investigator a -> Investigator b -> Investigator c -> Claim"
            },
            {
                "name": "claim3True",
                "comment": "",
                "type": "String -> (a -> b -> c -> Bool) -> Investigator a -> Investigator b -> Investigator c -> Claim"
            },
            {
                "name": "claim4",
                "comment": "",
                "type": "String -> (a -> b -> c -> d -> e) -> (a -> b -> c -> d -> e) -> Investigator a -> Investigator b -> Investigator c -> Investigator d -> Claim"
            },
            {
                "name": "claim4False",
                "comment": "",
                "type": "String -> (a -> b -> c -> d -> Bool) -> Investigator a -> Investigator b -> Investigator c -> Investigator d -> Claim"
            },
            {
                "name": "claim4True",
                "comment": "",
                "type": "String -> (a -> b -> c -> d -> Bool) -> Investigator a -> Investigator b -> Investigator c -> Investigator d -> Claim"
            },
            {
                "name": "claim5",
                "comment": "",
                "type": "String -> (a -> b -> c -> d -> e -> f) -> (a -> b -> c -> d -> e -> f) -> Investigator a -> Investigator b -> Investigator c -> Investigator d -> Investigator e -> Claim"
            },
            {
                "name": "claim5False",
                "comment": "",
                "type": "String -> (a -> b -> c -> d -> e -> Bool) -> Investigator a -> Investigator b -> Investigator c -> Investigator d -> Investigator e -> Claim"
            },
            {
                "name": "claim5True",
                "comment": "",
                "type": "String -> (a -> b -> c -> d -> e -> Bool) -> Investigator a -> Investigator b -> Investigator c -> Investigator d -> Investigator e -> Claim"
            },
            {
                "name": "claimFalse",
                "comment": "Make a claim of falsiness about a system.\n\nAnalogous to `claimTrue`, `claimFalse` only considers claims which always yield\n`False` to be true. If `claimFalse` manages to find an input which causes the\ngiven predicate to yield `True`, then it will consider that as the counter\nexample.\n\n    claimFalse nameOfClaim predicate investigator\n\n\nExample:\n\n    claim_length_list_never_negative =\n      claimFalse \"The length of a list is never negative\"\n      (\\list -> List.length list < 0)\n      (list float)",
                "type": "String -> (a -> Bool) -> Investigator a -> Claim"
            },
            {
                "name": "claimTrue",
                "comment": "Make a claim of truth about a system.\n\nSimilar to `claim`, `claimTrue` only considers claims which always yield `True`\nto be true. If `claimTrue` manages to find an input which causes the given\npredicate to yield `False`, then it will consider that as the counter example.\n\n    claimTrue nameOfClaim predicate investigator\n\n\nExample:\n\n    claim_length_list_nonnegative =\n      claimTrue \"The length of a list is strictly non-negative\"\n        (\\list -> List.length list >= 0)\n        (list string)",
                "type": "String -> (a -> Bool) -> Investigator a -> Claim"
            },
            {
                "name": "false",
                "comment": "",
                "type": "((a -> Bool) -> (a -> Bool) -> Investigator a -> Claim) -> (a -> Bool) -> Investigator a -> Claim"
            },
            {
                "name": "for",
                "comment": "",
                "type": "(Investigator a -> Claim) -> Investigator a -> Claim"
            },
            {
                "name": "is",
                "comment": "",
                "type": "((a -> b) -> Investigator a -> Claim) -> (a -> b) -> Investigator a -> Claim"
            },
            {
                "name": "quickCheck",
                "comment": "Quick check a claim.\n\nThis function is very useful when checking claims locally. `quickCheck` will\nperform 100 checks and use `Random.initialSeed 1` as the random seed.\n\n    quickCheck claim =\n      check claim 100 (Random.initialSeed 1)",
                "type": "Claim -> Evidence"
            },
            {
                "name": "suite",
                "comment": "Group a list of claims into a suite. This is very useful in order to\ngroup similar claims together.\n\n    suite nameOfSuite listOfClaims",
                "type": "String -> List Claim -> Claim"
            },
            {
                "name": "that",
                "comment": "",
                "type": "((a -> b) -> (a -> b) -> Investigator a -> Claim) -> (a -> b) -> (a -> b) -> Investigator a -> Claim"
            },
            {
                "name": "true",
                "comment": "",
                "type": "((a -> Bool) -> (a -> Bool) -> Investigator a -> Claim) -> (a -> Bool) -> Investigator a -> Claim"
            }
        ],
        "binops": []
    },
    {
        "name": "Check.Investigator",
        "comment": "Sub-module containing the Investigator type used by elm-check.\n\nThis sub-module contains several predefined investigator generators and means of\ncomposing them to create your own. Note that most generators provided are\nonly well-suited to local development. Property-based testing is by its nature\na very slow process and is best paired with some sort of continuous integration\nservice. Consider making your own, more general investigator generators when\nmigrating from local to cloud-based.\n\n# Shrink\n@docs shrink\n\n# Investigator Definition\n@docs Investigator, investigator\n\n# Basic Investigator Generators\n@docs void, bool, order, random, int, rangeInt, float, percentage, char, upperCaseChar, lowerCaseChar, ascii, unicode, string, maybe, result, list, array, tuple, tuple3, tuple4, tuple5, func, func2, func3, func4, func5",
        "unions": [],
        "aliases": [
            {
                "name": "Investigator",
                "comment": "An Investigator type is a Random Generator paired with a shrinking strategy,\nor Shrinker. Shrinkers are defined in `elm-shrink`.",
                "args": [
                    "a"
                ],
                "type": "{ generator : Generator a, shrinker : Shrinker a }"
            }
        ],
        "values": [
            {
                "name": "array",
                "comment": "Investigator array constructor. Generates random arrays of values of size\nbetween 0 and 10 from a given investigator generator using the `rangeLengthArray`\ngenerator constructor from elm-random-extra and the `array` shrinker constructor\nfrom elm-shrink. Ideal for local testing.",
                "type": "Investigator a -> Investigator (Array a)"
            },
            {
                "name": "ascii",
                "comment": "Investigator char. Generates random ascii chars using the `ascii` generator\nfrom elm-random-extra and the `char` shrinker from elm-shrink. Ideal for local\ntesting or if your domain deals exclusively with ascii.",
                "type": "Investigator Char"
            },
            {
                "name": "bool",
                "comment": "Investigator bool. Uses the bool generator from elm-random-extra and the\n`bool` shrinker from elm-shrink.",
                "type": "Investigator Bool"
            },
            {
                "name": "char",
                "comment": "Investigator char. Generates random ascii chars disregarding the control\ncharacters using the `char 32 127` generator from elm-random-extra and the\n`character` shrinker from elm-shrink. Ideal for local testing or if your\ndomain deals exclusively with ascii and you do not care about control\ncharacters.",
                "type": "Investigator Char"
            },
            {
                "name": "float",
                "comment": "Investigator float. Generates random floats between -50 and 50 and the `float`\nshrinker from elm-shrink. Ideal for local testing.",
                "type": "Investigator Float"
            },
            {
                "name": "func",
                "comment": "Investigator of functions. Takes an investigator for the return type\nand returns an investigator of functions. Uses the `func` generator from\nelm-random-extra and does not perform any shrinking.",
                "type": "Investigator b -> Investigator (a -> b)"
            },
            {
                "name": "func2",
                "comment": "",
                "type": "Investigator c -> Investigator (a -> b -> c)"
            },
            {
                "name": "func3",
                "comment": "",
                "type": "Investigator d -> Investigator (a -> b -> c -> d)"
            },
            {
                "name": "func4",
                "comment": "",
                "type": "Investigator e -> Investigator (a -> b -> c -> d -> e)"
            },
            {
                "name": "func5",
                "comment": "",
                "type": "Investigator f -> Investigator (a -> b -> c -> d -> e -> f)"
            },
            {
                "name": "int",
                "comment": "Investigator int. Generates random ints between -50 and 50 and the `int`\nshrinker from elm-shrink. Ideal for local testing.",
                "type": "Investigator Int"
            },
            {
                "name": "investigator",
                "comment": "Investigator constructor. Construct an Investigator from a generator and\na shrinker.",
                "type": "Generator a -> Shrinker a -> Investigator a"
            },
            {
                "name": "list",
                "comment": "Investigator list constructor. Generates random lists of values of size\nbetween 0 and 10 from a given investigator generator using the `rangeLengthList`\ngenerator constructor from elm-random-extra and the `list` shrinker constructor\nfrom elm-shrink. Ideal for local testing.",
                "type": "Investigator a -> Investigator (List a)"
            },
            {
                "name": "lowerCaseChar",
                "comment": "Investigator char. Generates random ascii chars using the `lowerCaseLatin`\ngenerator from elm-random-extra and the `character` shrinker from elm-shrink.",
                "type": "Investigator Char"
            },
            {
                "name": "maybe",
                "comment": "Investigator maybe constructor. Generates random maybe values from a given\ninvestigator generator using the `maybe` generator constructor from\nelm-random-extra and the `maybe` shrinker constructor from elm-shrink.",
                "type": "Investigator a -> Investigator (Maybe a)"
            },
            {
                "name": "order",
                "comment": "Investigator order. Uses the order generator from elm-random-extra and the\n`order` shrinker from elm-shrink.",
                "type": "Investigator Order"
            },
            {
                "name": "percentage",
                "comment": "Investigator percentage. Generates random floats between 0.0 and 1.0 and the `float`\nshrinker from elm-shrink. Useful in conjunction with `tuple` to facilitate\nthings like generating an array and then selecting one of its elements at random.",
                "type": "Investigator Float"
            },
            {
                "name": "random",
                "comment": "Extract a Random Generator from and an Investigator generator.",
                "type": "Investigator a -> Generator a"
            },
            {
                "name": "rangeInt",
                "comment": "Investigator int constructor. Generates random ints between a given `min`\nand a given `max` value.",
                "type": "Int -> Int -> Investigator Int"
            },
            {
                "name": "result",
                "comment": "Investigator result constructor. Generates random result values from a given\ninvestigator generator using the `result` generator constructor from\nelm-random-extra and the `result` shrinker constrctor from elm-shrink.",
                "type": "Investigator error -> Investigator value -> Investigator (Result error value)"
            },
            {
                "name": "shrink",
                "comment": "Shrink a value from an Investigator generator.\n\n    int : Investigator Int\n\n    shrink int 10 == [0,5,7,8,9]",
                "type": "Investigator a -> Shrinker a"
            },
            {
                "name": "string",
                "comment": "Investigator string. Generates random ascii strings of size between 0 and 10\nusing the `rangeLengthString` generator from elm-random-extra and the `string`\nshrinker from elm-shrink. Ideal for local testing.",
                "type": "Investigator String"
            },
            {
                "name": "tuple",
                "comment": "Investigator 2-tuple constructor. Generates random 2-tuples from a 2-tuple\nof investigator generators. Uses the `tuple` shrinker constructor from elm-shrink.",
                "type": "( Investigator a, Investigator b ) -> Investigator ( a, b )"
            },
            {
                "name": "tuple3",
                "comment": "Investigator 3-tuple constructor. Generates random 3-tuples from a 3-tuple\nof investigator generators. Uses the `tuple3` shrinker constrctor from elm-shrink.",
                "type": "( Investigator a, Investigator b, Investigator c ) -> Investigator ( a, b, c )"
            },
            {
                "name": "tuple4",
                "comment": "Investigator 4-tuple constructor. Generates random 4-tuples from a 4-tuple\nof investigator generators. Uses the `tuple4` shrinker constrctor from elm-shrink.",
                "type": "( Investigator a, Investigator b, Investigator c, Investigator d ) -> Investigator ( a, b, c, d )"
            },
            {
                "name": "tuple5",
                "comment": "Investigator 5-tuple constructor. Generates random 5-tuples from a 5-tuple\nof investigator generators. Uses the `tuple5` shrinker constrctor from elm-shrink.",
                "type": "( Investigator a, Investigator b, Investigator c, Investigator d, Investigator e ) -> Investigator ( a, b, c, d, e )"
            },
            {
                "name": "unicode",
                "comment": "Investigator char. Generates a random UTF-8 character using the\n`unicode` generator from elm-random-extra and the `char` shrinker from\nelm-shrink.",
                "type": "Investigator Char"
            },
            {
                "name": "upperCaseChar",
                "comment": "Investigator char. Generates random ascii chars using the `upperCaseLatin`\ngenerator from elm-random-extra and the `character` shrinker from elm-shrink.",
                "type": "Investigator Char"
            },
            {
                "name": "void",
                "comment": "Investigator void. Uses a constant generator and the `void` shrinker from\nelm-shrink.",
                "type": "Investigator ()"
            }
        ],
        "binops": []
    }
]