[
    {
        "name": "Test.Runner",
        "comment": " A collection of functions used by authors of test runners. To run your\nown tests, you should use these runners; see the `README` for more information.\n\n## Runner\n\n@docs Runner, fromTest\n\n## Runnable\n\n@docs Runnable, run\n\n## Formatting\n\n@docs formatLabels\n",
        "unions": [
            {
                "name": "Runnable",
                "comment": " An unevaluated test. Run it with [`run`](#run) to evaluate it into a\nlist of `Expectation`s.\n",
                "args": [],
                "cases": []
            },
            {
                "name": "Runner",
                "comment": " A structured test runner, incorporating:\n\n* The expectations to run\n* The hierarchy of description strings that describe the results\n",
                "args": [],
                "cases": [
                    [
                        "Runnable",
                        [
                            "Runnable"
                        ]
                    ],
                    [
                        "Labeled",
                        [
                            "String",
                            "Runner"
                        ]
                    ],
                    [
                        "Batch",
                        [
                            "List Runner"
                        ]
                    ]
                ]
            }
        ],
        "aliases": [],
        "values": [
            {
                "name": "formatLabels",
                "comment": " A standard way to format descriptiona and test labels, to keep things\nconsistent across test runner implementations.\n\nThe HTML, Node, String, and Log runners all use this.\n\nWhat it does:\n\n* drop any labels that are empty strings\n* format the first label differently from the others\n* reverse the resulting list\n\n    [ \"the actual test that failed\"\n    , \"nested description failure\"\n    , \"top-level description failure\"\n    ]\n        |> formatLabels ((++) \"↓ \") ((++) \"✗ \")\n\n    {-\n        [ \"↓ top-level description failure\"\n        , \"↓ nested description failure\"\n        , \"✗ the actual test that failed\"\n        ]\n    -}\n\n",
                "type": "(String -> format) -> (String -> format) -> List String -> List format"
            },
            {
                "name": "fromTest",
                "comment": " Convert a `Test` into a `Runner`.\n\nIn order to run any fuzz tests that the `Test` may have, it requires a default run count as well\nas an initial `Random.Pcg.Seed`. `100` is a good run count. To obtain a good random seed, pass a\nrandom 32-bit integer to `Random.Pcg.initialSeed`. You can obtain such an integer by running\n`Math.floor(Math.random()*0xFFFFFFFF)` in Node. It's typically fine to hard-code this value into\nyour Elm code; it's easy and makes your tests reproducible.\n",
                "type": "Int -> Seed -> Test -> Runner"
            },
            {
                "name": "run",
                "comment": " Evaluate a [`Runnable`](#Runnable) to get a list of `Expectation`s.\n",
                "type": "Runnable -> List Expectation"
            }
        ],
        "binops": []
    },
    {
        "name": "Test",
        "comment": " A module containing functions for creating and managing tests.\n\n@docs Test, test\n\n## Organizing Tests\n\n@docs describe, concat, filter\n\n## Fuzz Testing\n\n@docs fuzz, fuzz2, fuzz3, fuzz4, fuzz5, fuzzWith, FuzzOptions\n",
        "unions": [],
        "aliases": [
            {
                "name": "FuzzOptions",
                "comment": " Options [`fuzzWith`](#fuzzWith) accepts. Currently there is only one but this\nAPI is designed so that it can accept more in the future.\n\n### `runs`\n\nThe number of times to run each fuzz test. (Default is 100.)\n\n    import Test exposing (fuzzWith)\n    import Fuzz exposing (list, int)\n    import Expect\n\n\n    fuzzWith { runs = 350 } (list int) \"List.length should always be positive\" <|\n        -- This anonymous function will be run 350 times, each time with a\n        -- randomly-generated fuzzList value. (It will always be a list of ints\n        -- because of (list int) above.)\n        \\fuzzList ->\n            fuzzList\n                |> List.length\n                |> Expect.atLeast 0\n",
                "args": [],
                "type": "{ runs : Int }"
            },
            {
                "name": "Test",
                "comment": " A test which has yet to be evaluated. When evaluated, it produces one\nor more [`Expectation`](../Expect#Expectation)s.\n\nSee [`test`](#test) and [`fuzz`](#fuzz) for some ways to create a `Test`.\n",
                "args": [],
                "type": "Test"
            }
        ],
        "values": [
            {
                "name": "concat",
                "comment": " Run each of the given tests.\n\n    concat [ testDecoder, testSorting ]\n",
                "type": "List Test -> Test"
            },
            {
                "name": "describe",
                "comment": " Apply a description to a list of tests.\n\n    import Test exposing (describe, test, fuzz)\n    import Fuzz expoing (int)\n    import Expect\n\n\n    describe \"List\"\n        [ describe \"reverse\"\n            [ test \"has no effect on an empty list\" <|\n                \\() ->\n                    List.reverse []\n                        |> Expect.toEqual []\n            , fuzz int \"has no effect on a one-item list\" <|\n                \\num ->\n                     List.reverse [ num ]\n                        |> Expect.toEqual [ num ]\n            ]\n        ]\n",
                "type": "String -> List Test -> Test"
            },
            {
                "name": "filter",
                "comment": " Remove any test unless its description satisfies the given predicate\nfunction. Nested descriptions added with [`describe`](#describe) are not considered.\n\n    describe \"String.reverse\"\n        [ test \"has no effect on a palindrome\" testGoesHere\n        , test \"reverses a known string\" anotherTest\n        , fuzz string \"restores the original string if you run it again\" oneMore\n        ]\n            |> Test.filter (String.contains \"original\")\n\n    -- only runs the final test\n\nYou can use this to focus on a specific test or two, silencing the failures of\ntests you don't want to work on yet, and then remove the call to `Test.filter`\nafter you're done working on the tests.\n",
                "type": "(String -> Bool) -> Test -> Test"
            },
            {
                "name": "fuzz",
                "comment": " Take a function that produces a test, and calls it several (usually 100) times, using a randomly-generated input\nfrom a [`Fuzzer`](http://package.elm-lang.org/packages/elm-community/elm-test/latest/Fuzz) each time. This allows you to\ntest that a property that should always be true is indeed true under a wide variety of conditions. The function also\ntakes a string describing the test.\n\nThese are called \"[fuzz tests](https://en.wikipedia.org/wiki/Fuzz_testing)\" because of the randomness.\nYou may find them elsewhere called [property-based tests](http://blog.jessitron.com/2013/04/property-based-testing-what-is-it.html),\n[generative tests](http://www.pivotaltracker.com/community/tracker-blog/generative-testing), or\n[QuickCheck-style tests](https://en.wikipedia.org/wiki/QuickCheck).\n\n    import Test exposing (fuzz)\n    import Fuzz exposing (list, int)\n    import Expect\n\n\n    fuzz (list int) \"List.length should always be positive\" <|\n        -- This anonymous function will be run 100 times, each time with a\n        -- randomly-generated fuzzList value.\n        \\fuzzList ->\n            fuzzList\n                |> List.length\n                |> Expect.atLeast 0\n",
                "type": "Fuzzer a -> String -> (a -> Expectation) -> Test"
            },
            {
                "name": "fuzz2",
                "comment": " Run a [fuzz test](#fuzz) using two random inputs.\n\nThis is a convenicence function that lets you skip calling [`Fuzz.tuple`](../Fuzz#tuple).\n\nSee [`fuzzWith`](#fuzzWith) for an example of writing this in tuple style.\n\n    import Test exposing (fuzz2)\n    import Fuzz exposing (list, int)\n\n\n    fuzz2 (list int) int \"List.reverse never influences List.member\" <|\n        \\nums target ->\n            List.member target (List.reverse nums)\n                |> Expect.toEqual (List.member target nums)\n",
                "type": "Fuzzer a -> Fuzzer b -> String -> (a -> b -> Expectation) -> Test"
            },
            {
                "name": "fuzz3",
                "comment": " Run a [fuzz test](#fuzz) using three random inputs.\n\nThis is a convenicence function that lets you skip calling [`Fuzz.tuple3`](../Fuzz#tuple3).\n",
                "type": "Fuzzer a -> Fuzzer b -> Fuzzer c -> String -> (a -> b -> c -> Expectation) -> Test"
            },
            {
                "name": "fuzz4",
                "comment": " Run a [fuzz test](#fuzz) using four random inputs.\n\nThis is a convenicence function that lets you skip calling [`Fuzz.tuple4`](../Fuzz#tuple4).\n",
                "type": "Fuzzer a -> Fuzzer b -> Fuzzer c -> Fuzzer d -> String -> (a -> b -> c -> d -> Expectation) -> Test"
            },
            {
                "name": "fuzz5",
                "comment": " Run a [fuzz test](#fuzz) using five random inputs.\n\nThis is a convenicence function that lets you skip calling [`Fuzz.tuple5`](../Fuzz#tuple5).\n",
                "type": "Fuzzer a -> Fuzzer b -> Fuzzer c -> Fuzzer d -> Fuzzer e -> String -> (a -> b -> c -> d -> e -> Expectation) -> Test"
            },
            {
                "name": "fuzzWith",
                "comment": " Run a [`fuzz`](#fuzz) test with the given [`FuzzOptions`](#FuzzOptions).\n\nNote that there is no `fuzzWith2`, but you can always pass more fuzz values in\nusing [`Fuzz.tuple`](../Fuzz#tuple), [`Fuzz.tuple3`](../Fuzz#tuple3),\nfor example like this:\n\n    import Test exposing (fuzzWith)\n    import Fuzz exposing (tuple, list, int)\n    import Expect\n\n\n    fuzzWith { runs = 4200 }\n        (tuple ( list int, int ))\n        \"List.reverse never influences List.member\" <|\n            \\(nums, target) ->\n                List.member target (List.reverse nums)\n                    |> Expect.toEqual (List.member target nums)\n",
                "type": "FuzzOptions -> Fuzzer a -> String -> (a -> Expectation) -> Test"
            },
            {
                "name": "test",
                "comment": " Return a [`Test`](#Test) that evaluates a single\n[`Expectation`](../Expect#Expectation).\n\n    import Test exposing (fuzz)\n    import Expect\n\n\n    test \"the empty list has 0 length\" <|\n        \\() ->\n            List.length []\n                |> Expect.toEqual 0\n",
                "type": "String -> (() -> Expectation) -> Test"
            }
        ],
        "binops": []
    },
    {
        "name": "Expect",
        "comment": " A library to create `Expectation`s, which describe a claim to be tested.\n\n## Quick Reference\n\n* [`equal`](#equal) `(arg2 == arg1)`\n* [`notEqual`](#notEqual) `(arg2 /= arg1)`\n* [`lessThan`](#lessThan) `(arg2 < arg1)`\n* [`atMost`](#atMost) `(arg2 <= arg1)`\n* [`greaterThan`](#greaterThan) `(arg2 > arg1)`\n* [`atLeast`](#atLeast) `(arg2 >= arg1)`\n* [`true`](#true) `(arg == True)`\n* [`false`](#false) `(arg == False)`\n\n## Basic Expectations\n\n@docs Expectation, equal, notEqual\n\n## Comparisons\n\n@docs lessThan, atMost, greaterThan, atLeast\n\n## Booleans\n\n@docs true, false\n\n## Customizing\n\n@docs pass, fail, onFail, getFailure\n",
        "unions": [],
        "aliases": [
            {
                "name": "Expectation",
                "comment": " The result of a single test run: either a [`pass`](#pass) or a\n[`fail`](#fail).\n",
                "args": [],
                "type": "Expectation"
            }
        ],
        "values": [
            {
                "name": "atLeast",
                "comment": " Passes if the second argument is greater than or equal to the first.\n\n    Expect.atLeast -2 (List.length [])\n\n    -- Passes because (0 >= -2) is True\n\nFailures resemble code written in pipeline style, so you can tell\nwhich argument is which:\n\n    -- Fails because (0 >= 3) is False\n    List.length []\n        |> Expect.atLeast 3\n\n    {-\n\n    0\n    ╷\n    │ Expect.atLeast\n    ╵\n    3\n\n    -}\n",
                "type": "comparable -> comparable -> Expectation"
            },
            {
                "name": "atMost",
                "comment": " Passes if the second argument is less than or equal to the first.\n\n    Expect.atMost 1 (List.length [])\n\n    -- Passes because (0 <= 1) is True\n\nFailures resemble code written in pipeline style, so you can tell\nwhich argument is which:\n\n    -- Fails because (0 <= -3) is False\n    List.length []\n        |> Expect.atMost -3\n\n    {-\n\n    0\n    ╷\n    │ Expect.atMost\n    ╵\n    -3\n\n    -}\n",
                "type": "comparable -> comparable -> Expectation"
            },
            {
                "name": "equal",
                "comment": " Passes if the arguments are equal.\n\n    Expect.equal 0 (List.length [])\n\n    -- Passes because (0 == 0) is True\n\nFailures resemble code written in pipeline style, so you can tell\nwhich argument is which:\n\n    -- Fails because the expected value didn't split the space in \"Betty Botter\"\n    String.split \" \" \"Betty Botter bought some butter\"\n        |> Expect.equal [ \"Betty Botter\", \"bought\", \"some\", \"butter\" ]\n\n    {-\n\n    [ \"Betty\", \"Botter\", \"bought\", \"some\", \"butter\" ]\n    ╷\n    │ Expect.equal\n    ╵\n    [ \"Betty Botter\", \"bought\", \"some\", \"butter\" ]\n\n    -}\n",
                "type": "a -> a -> Expectation"
            },
            {
                "name": "fail",
                "comment": " Fails with the given message.\n\n    import Json.Decode exposing (decodeString, int)\n    import Test exposing (test)\n    import Expect\n\n\n    test \"Json.Decode.int can decode the number 42.\" <|\n        \\() ->\n            case decodeString int \"42\" of\n                Ok _ ->\n                    Expect.pass\n\n                Err err ->\n                    Expect.fail err\n",
                "type": "String -> Expectation"
            },
            {
                "name": "false",
                "comment": " Passes if the argument is 'False', and otherwise fails with the given message.\n\n    Expect.false \"Expected the list not to be empty.\" (List.isEmpty [ 42 ])\n\n    -- Passes because (List.isEmpty [ 42 ]) is False\n\nFailures resemble code written in pipeline style, so you can tell\nwhich argument is which:\n\n    -- Fails because (List.isEmpty []) is True\n    List.isEmpty []\n        |> Expect.false \"Expected the list not to be empty.\"\n\n    {-\n\n    Expected the list not to be empty.\n\n    -}\n",
                "type": "String -> Bool -> Expectation"
            },
            {
                "name": "getFailure",
                "comment": " Return `Nothing` if the given [`Expectation`](#Expectation) is a [`pass`](#pass).\n\nIf it is a [`fail`](#fail), return a record containing the failure message,\nalong with the given inputs if it was a fuzz test. (If no inputs were involved,\nthe record's `given` field will be `\"\"`).\n\nFor example, if a fuzz test generates random integers, this might return\n`{ message = \"it was supposed to be positive\", given = \"-1\" }`\n\n    getFailure (Expect.fail \"this failed\")\n    -- Just { message = \"this failed\", given = \"\" }\n\n    getFailure (Expect.pass)\n    -- Nothing\n",
                "type": "Expectation -> Maybe { given : String, message : String }"
            },
            {
                "name": "greaterThan",
                "comment": " Passes if the second argument is greater than the first.\n\n    Expect.greaterThan -2 List.length []\n\n    -- Passes because (0 > -2) is True\n\nFailures resemble code written in pipeline style, so you can tell\nwhich argument is which:\n\n    -- Fails because (0 > 1) is False\n    List.length []\n        |> Expect.greaterThan 1\n\n    {-\n\n    0\n    ╷\n    │ Expect.greaterThan\n    ╵\n    1\n\n    -}\n",
                "type": "comparable -> comparable -> Expectation"
            },
            {
                "name": "lessThan",
                "comment": " Passes if the second argument is less than the first.\n\n    Expect.lessThan 1 (List.length [])\n\n    -- Passes because (0 < 1) is True\n\nFailures resemble code written in pipeline style, so you can tell\nwhich argument is which:\n\n    -- Fails because (0 < -1) is False\n    List.length []\n        |> Expect.lessThan -1\n\n\n    {-\n\n    0\n    ╷\n    │ Expect.lessThan\n    ╵\n    -1\n\n    -}\n",
                "type": "comparable -> comparable -> Expectation"
            },
            {
                "name": "notEqual",
                "comment": " Passes if the arguments are not equal.\n\n    -- Passes because (11 /= 100) is True\n    90 + 10\n        |> Expect.notEqual 11\n\n\n    -- Fails because (100 /= 100) is False\n    90 + 10\n        |> Expect.notEqual 100\n\n    {-\n\n    100\n    ╷\n    │ Expect.notEqual\n    ╵\n    100\n\n    -}\n",
                "type": "a -> a -> Expectation"
            },
            {
                "name": "onFail",
                "comment": " If the given expectation fails, replace its failure message with a custom one.\n\n    \"something\"\n        |> Expect.equal \"something else\"\n        |> Expect.onFail \"thought those two strings would be the same\"\n",
                "type": "String -> Expectation -> Expectation"
            },
            {
                "name": "pass",
                "comment": " Always passes.\n\n    import Json.Decode exposing (decodeString, int)\n    import Test exposing (test)\n    import Expect\n\n\n    test \"Json.Decode.int can decode the number 42.\" <|\n        \\() ->\n            case decodeString int \"42\" of\n                Ok _ ->\n                    Expect.pass\n\n                Err err ->\n                    Expect.fail err\n",
                "type": "Expectation"
            },
            {
                "name": "true",
                "comment": " Passes if the argument is 'True', and otherwise fails with the given message.\n\n    Expect.true \"Expected the list to be empty.\" (List.isEmpty [])\n\n    -- Passes because (List.isEmpty []) is True\n\nFailures resemble code written in pipeline style, so you can tell\nwhich argument is which:\n\n    -- Fails because List.isEmpty returns False, but we expect True.\n    List.isEmpty [ 42 ]\n        |> Expect.true \"Expected the list to be empty.\"\n\n    {-\n\n    Expected the list to be empty.\n\n    -}\n",
                "type": "String -> Bool -> Expectation"
            }
        ],
        "binops": []
    },
    {
        "name": "Fuzz",
        "comment": " This is a library of *fuzzers* you can use to supply values to your fuzz\ntests. You can typically pick out which ones you need according to their types.\n\nA `Fuzzer a` knows how to create values of type `a` in two different ways. It\ncan create them randomly, so that your test's expectations are run against many\nvalues. Fuzzers will often generate edge cases likely to find bugs. If the\nfuzzer can make your test fail, it also knows how to \"shrink\" that failing input\ninto more minimal examples, some of which might also cause the tests to fail. In\nthis way, fuzzers can usually find the smallest or simplest input that\nreproduces a bug.\n\n## Common Fuzzers\n@docs bool, int, intRange, float, floatRange, percentage, string, maybe, result, list, array\n\n## Working with Fuzzers\n@docs Fuzzer, map, frequency, frequencyOrCrash\n\n## Tuple Fuzzers\nInstead of using a tuple, consider using `fuzzN`.\n@docs tuple, tuple3, tuple4, tuple5\n\n## Uncommon Fuzzers\n@docs custom, char, unit, order\n\n",
        "unions": [],
        "aliases": [
            {
                "name": "Fuzzer",
                "comment": " The representation of fuzzers is opaque. Conceptually, a `Fuzzer a`\nconsists of a way to randomly generate values of type `a`, and a way to shrink\nthose values.\n",
                "args": [
                    "a"
                ],
                "type": "Fuzzer a"
            }
        ],
        "values": [
            {
                "name": "array",
                "comment": " Given a fuzzer of a type, create a fuzzer of an array of that type.\nGenerates random arrays of varying length, favoring shorter arrays.\n",
                "type": "Fuzzer a -> Fuzzer (Array a)"
            },
            {
                "name": "bool",
                "comment": " A fuzzer for bool values.\n",
                "type": "Fuzzer Bool"
            },
            {
                "name": "char",
                "comment": " A fuzzer for char values. Generates random ascii chars disregarding the control\ncharacters.\n",
                "type": "Fuzzer Char"
            },
            {
                "name": "custom",
                "comment": " Build a custom `Fuzzer a` by providing a `Generator a` and a `Shrinker a`.\nGenerators are defined by [`mgold/elm-random-pcg`](http://package.elm-lang.org/packages/mgold/elm-random-pcg/latest),\nwhich is not core's Random module but has a compatible interface. Shrinkers are\ndefined in [`elm-community/shrink`](http://package.elm-lang.org/packages/elm-community/shrink/latest/).\n\nHere is an example for a record:\n\n    import Random.Pcg as Random\n    import Shrink\n\n    type alias Position =\n        { x : Int, y : Int }\n\n\n    position : Fuzzer Position\n    position =\n        Fuzz.custom\n            (Random.map2 Position (Random.int -100 100) (Random.int -100 100))\n            (\\{ x, y } -> Shrink.map Position (Shrink.int x) `Shrink.andMap` (Shrink.int y))\n\nHere is an example for a custom union type:\n\n    type Question\n        = Name String\n        | Age Int\n\n\n    question =\n        let\n            generator =\n                Random.bool `Random.andThen` (\\b ->\n                    if b then\n                        Random.map Name string.generator\n                    else\n                        Random.map Age (Random.int 0 120)\n                 )\n\n            shrinker question =\n                case question of\n                    Name n ->\n                        Shrink.string n |> Shrink.map Name\n\n                    Age i ->\n                        Shrink.int i |> Shrink.map Age\n        in\n            Fuzz.custom generator shrinker\n",
                "type": "Generator a -> Shrinker a -> Fuzzer a"
            },
            {
                "name": "float",
                "comment": " A fuzzer for float values. It will never produce `NaN`, `Infinity`, or `-Infinity`.\n",
                "type": "Fuzzer Float"
            },
            {
                "name": "floatRange",
                "comment": " A fuzzer for float values within between a given minimum and maximum\nvalue, inclusive. Shrunken values will also be within the range.\n",
                "type": "Float -> Float -> Fuzzer Float"
            },
            {
                "name": "frequency",
                "comment": " Create a new fuzzer by providing a list of fuzzers to pick from. Each fuzzer\nis associated with a `Float` weight; larger numbers mean the fuzzer in more\nlikely to get picked from.\n\nFor example, to create a `Fuzzer` that has a 1/4 chance of generating an int\nbetween -1 and -100, and a 3/4 chance of generating one between 1 and 100,\nyou could do this:\n\n    Fuzz.frequency\n        [ ( 1, Fuzz.intRange -100 -1 )\n        , ( 3, Fuzz.intRange 1 100 )\n        ]\n\nThis function returns a `Result` because it can fail in a few ways:\n\n* If you provide an empy list of frequencies\n* If any of the weights are less than 0\n* If the weights sum to 0\n\nAny of these will lead to an `Err`, with a `String` explaining what went wrong.\n",
                "type": "List ( Float, Fuzzer a ) -> Result String (Fuzzer a)"
            },
            {
                "name": "frequencyOrCrash",
                "comment": " Calls `frequency` and handles `Err` results by crashing with the given\nerror message.\n\nThis is useful in tests, where a crash will simply cause the test run to fail.\nThere is no danger to a production system there.\n",
                "type": "List ( Float, Fuzzer a ) -> Fuzzer a"
            },
            {
                "name": "int",
                "comment": " A fuzzer for int values.\n",
                "type": "Fuzzer Int"
            },
            {
                "name": "intRange",
                "comment": " A fuzzer for int values within between a given minimum and maximum value,\ninclusive. Shrunken values will also be within the range.\n",
                "type": "Int -> Int -> Fuzzer Int"
            },
            {
                "name": "list",
                "comment": " Given a fuzzer of a type, create a fuzzer of a list of that type.\nGenerates random lists of varying length, favoring shorter lists.\n",
                "type": "Fuzzer a -> Fuzzer (List a)"
            },
            {
                "name": "map",
                "comment": " Map a function over a fuzzer. Due to technical limitations, the resulting\nfuzzer performs no shrinking.\n",
                "type": "(a -> b) -> Fuzzer a -> Fuzzer b"
            },
            {
                "name": "maybe",
                "comment": " Given a fuzzer of a type, create a fuzzer of a maybe for that type.\n",
                "type": "Fuzzer a -> Fuzzer (Maybe a)"
            },
            {
                "name": "order",
                "comment": " A fuzzer for order values.\n",
                "type": "Fuzzer Order"
            },
            {
                "name": "percentage",
                "comment": " A fuzzer for percentage values. Generates random floats between `0.0` and\n`1.0`. It will test zero and one about 10% of the time each.\n",
                "type": "Fuzzer Float"
            },
            {
                "name": "result",
                "comment": " Given fuzzers for an error type and a success type, create a fuzzer for\na result.\n",
                "type": "Fuzzer error -> Fuzzer value -> Fuzzer (Result error value)"
            },
            {
                "name": "string",
                "comment": " A fuzzer for string values. Generates random printable ascii strings whose\nlength is between 0 and 10.\n",
                "type": "Fuzzer String"
            },
            {
                "name": "tuple",
                "comment": " Turn a tuple of fuzzers into a fuzzer of tuples.\n",
                "type": "( Fuzzer a, Fuzzer b ) -> Fuzzer ( a, b )"
            },
            {
                "name": "tuple3",
                "comment": " Turn a 3-tuple of fuzzers into a fuzzer of 3-tuples.\n",
                "type": "( Fuzzer a, Fuzzer b, Fuzzer c ) -> Fuzzer ( a, b, c )"
            },
            {
                "name": "tuple4",
                "comment": " Turn a 4-tuple of fuzzers into a fuzzer of 4-tuples.\n",
                "type": "( Fuzzer a, Fuzzer b, Fuzzer c, Fuzzer d ) -> Fuzzer ( a, b, c, d )"
            },
            {
                "name": "tuple5",
                "comment": " Turn a 5-tuple of fuzzers into a fuzzer of 5-tuples.\n",
                "type": "( Fuzzer a, Fuzzer b, Fuzzer c, Fuzzer d, Fuzzer e ) -> Fuzzer ( a, b, c, d, e )"
            },
            {
                "name": "unit",
                "comment": " A fuzzer for the unit value. Unit is a type with only one value, commonly\nused as a placeholder.\n",
                "type": "Fuzzer ()"
            }
        ],
        "binops": []
    }
]