[
    {
        "name": "Lazy.List",
        "comment": "Lazy list implementation in Elm.\n\n# Types\n@docs LazyList, LazyListView\n\n# Constructors\n@docs cons, empty, singleton\n\n# Query operations\n@docs isEmpty, head, tail, member, length\n\n# Conversions\n@docs toList, fromList, toArray, fromArray\n\n# Map-reduce et al.\n@docs map, zip, reduce, flatten, flatMap, append, foldl, foldr\n\n# Common operations\n@docs intersperse, interleave, reverse, cycle, iterate, repeat, take, takeWhile, drop, dropWhile\n\n# Filtering operations\n@docs keepIf, dropIf, unique\n\n# Chaining operations\n@docs andMap, andThen\n\n# Useful stuff\n@docs numbers, sum, product\n\n# All the maps!\n@docs map2, map3, map4, map5\n\n# All the zips!\n@docs zip3, zip4, zip5\n\n# Infix Operators\n@docs (:::), (+++)\n\n# Random Generation Helpers\n@docs genList, lazylist",
        "unions": [
            {
                "name": "LazyListView",
                "comment": "Analogous to `List` type. This is the actual implementation type for the\n`LazyList` type. This type is exposed to the user if the user so wishes to\ndo pattern matching or understand how the list type works. It is not\nrecommended to work with this type directly. Try working solely with the\nprovided functions in the package.",
                "args": [
                    "a"
                ],
                "cases": [
                    [
                        "Nil",
                        []
                    ],
                    [
                        "Cons",
                        [
                            "a",
                            "LazyList a"
                        ]
                    ]
                ]
            }
        ],
        "aliases": [
            {
                "name": "LazyList",
                "comment": "Lazy List type.",
                "args": [
                    "a"
                ],
                "type": "Lazy (LazyListView a)"
            }
        ],
        "values": [
            {
                "name": "andMap",
                "comment": "Known as `mapN` in some circles. Allows you to apply `map` in cases\nwhere then number of arguments are greater than 5.",
                "type": "LazyList (a -> b) -> LazyList a -> LazyList b"
            },
            {
                "name": "andThen",
                "comment": "Chain list producing operations.",
                "type": "LazyList a -> (a -> LazyList b) -> LazyList b"
            },
            {
                "name": "append",
                "comment": "Append a list to another list.",
                "type": "LazyList a -> LazyList a -> LazyList a"
            },
            {
                "name": "cons",
                "comment": "Add a value to the front of a list.",
                "type": "a -> LazyList a -> LazyList a"
            },
            {
                "name": "cycle",
                "comment": "Take a list and repeat it ad infinitum. This cycles a finite list\nby putting the front after the end of the list. This results in a no-op in\nthe case of an infinite list.",
                "type": "LazyList a -> LazyList a"
            },
            {
                "name": "drop",
                "comment": "Drop at most `n` many values from a list.",
                "type": "Int -> LazyList a -> LazyList a"
            },
            {
                "name": "dropIf",
                "comment": "Drop all elements in a list that satisfy the given predicate.",
                "type": "(a -> Bool) -> LazyList a -> LazyList a"
            },
            {
                "name": "dropWhile",
                "comment": "Drop elements from a list as long as the predicate is satisfied.",
                "type": "(a -> Bool) -> LazyList a -> LazyList a"
            },
            {
                "name": "empty",
                "comment": "Create an empty list.",
                "type": "LazyList a"
            },
            {
                "name": "flatMap",
                "comment": "Map then flatten.",
                "type": "(a -> LazyList b) -> LazyList a -> LazyList b"
            },
            {
                "name": "flatten",
                "comment": "Flatten a list of lists into a single list by appending all the inner\nlists into one big list.",
                "type": "LazyList (LazyList a) -> LazyList a"
            },
            {
                "name": "foldl",
                "comment": "Analogous to `List.foldl`. Is an alias for `reduce`.",
                "type": "(a -> b -> b) -> b -> LazyList a -> b"
            },
            {
                "name": "foldr",
                "comment": "Analogous to `List.foldr`.",
                "type": "(a -> b -> b) -> b -> LazyList a -> b"
            },
            {
                "name": "fromArray",
                "comment": "Convert an array to a lazy list.",
                "type": "Array a -> LazyList a"
            },
            {
                "name": "fromList",
                "comment": "Convert a normal list to a lazy list.",
                "type": "List a -> LazyList a"
            },
            {
                "name": "genList",
                "comment": "Lazily randomly generate `n` many values.",
                "type": "Int -> Generator a -> Seed -> ( LazyList a, Seed )"
            },
            {
                "name": "head",
                "comment": "Get the head of a list.",
                "type": "LazyList a -> Maybe a"
            },
            {
                "name": "interleave",
                "comment": "Interleave the elements of a list in another list. The two lists get\ninterleaved at the end.",
                "type": "LazyList a -> LazyList a -> LazyList a"
            },
            {
                "name": "intersperse",
                "comment": "Places the given value between all members of the given list.",
                "type": "a -> LazyList a -> LazyList a"
            },
            {
                "name": "isEmpty",
                "comment": "Detect if a list is empty or not.",
                "type": "LazyList a -> Bool"
            },
            {
                "name": "iterate",
                "comment": "Create an infinite list of applications of a function on some value.\n\nEquivalent to:\n\n    x ::: f x ::: f (f x) ::: f (f (f x)) ::: ... -- etc...",
                "type": "(a -> a) -> a -> LazyList a"
            },
            {
                "name": "keepIf",
                "comment": "Keep all elements in a list that satisfy the given predicate.",
                "type": "(a -> Bool) -> LazyList a -> LazyList a"
            },
            {
                "name": "lazylist",
                "comment": "Analogue of `Random.list` generator constructor.",
                "type": "Int -> Generator a -> Generator (LazyList a)"
            },
            {
                "name": "length",
                "comment": "Get the length of a lazy list.\n\nWarning: This will not terminate if the list is infinite.",
                "type": "LazyList a -> Int"
            },
            {
                "name": "map",
                "comment": "Map a function to a list.",
                "type": "(a -> b) -> LazyList a -> LazyList b"
            },
            {
                "name": "map2",
                "comment": "",
                "type": "(a -> b -> c) -> LazyList a -> LazyList b -> LazyList c"
            },
            {
                "name": "map3",
                "comment": "",
                "type": "(a -> b -> c -> d) -> LazyList a -> LazyList b -> LazyList c -> LazyList d"
            },
            {
                "name": "map4",
                "comment": "",
                "type": "(a -> b -> c -> d -> e) -> LazyList a -> LazyList b -> LazyList c -> LazyList d -> LazyList e"
            },
            {
                "name": "map5",
                "comment": "",
                "type": "(a -> b -> c -> d -> e -> f) -> LazyList a -> LazyList b -> LazyList c -> LazyList d -> LazyList e -> LazyList f"
            },
            {
                "name": "member",
                "comment": "Test if a value is a member of a list.",
                "type": "a -> LazyList a -> Bool"
            },
            {
                "name": "numbers",
                "comment": "The list of counting numbers.\n\ni.e.:\n\n    1 ::: 2 ::: 3 ::: 4 ::: 5 ::: ... -- etc...",
                "type": "LazyList number"
            },
            {
                "name": "product",
                "comment": "Get the product of a list of numbers.",
                "type": "LazyList number -> number"
            },
            {
                "name": "reduce",
                "comment": "Reduce a list with a given reducer and an initial value.\n\nExample :\n    reduce (+) 0 (1 ::: 2 ::: 3 ::: 4 ::: empty) == 10",
                "type": "(a -> b -> b) -> b -> LazyList a -> b"
            },
            {
                "name": "repeat",
                "comment": "Repeat a value ad infinitum.\nBe careful when you use this. The result of this is a truly infinite list.\nDo not try calling `reduce` or `toList` on an infinite list as it'll never\nfinish computing. Make sure you then filter it down to a finite list with `head`\nor `take` or something.",
                "type": "a -> LazyList a"
            },
            {
                "name": "reverse",
                "comment": "Reverse a list.",
                "type": "LazyList a -> LazyList a"
            },
            {
                "name": "singleton",
                "comment": "Create a singleton list.",
                "type": "a -> LazyList a"
            },
            {
                "name": "sum",
                "comment": "Get the sum of a list of numbers.",
                "type": "LazyList number -> number"
            },
            {
                "name": "tail",
                "comment": "Get the tail of a list.",
                "type": "LazyList a -> Maybe (LazyList a)"
            },
            {
                "name": "take",
                "comment": "Take at most `n` many values from a list.",
                "type": "Int -> LazyList a -> LazyList a"
            },
            {
                "name": "takeWhile",
                "comment": "Take elements from a list as long as the predicate is satisfied.",
                "type": "(a -> Bool) -> LazyList a -> LazyList a"
            },
            {
                "name": "toArray",
                "comment": "Convert a lazy list to an array.",
                "type": "LazyList a -> Array a"
            },
            {
                "name": "toList",
                "comment": "Convert a lazy list to a normal list.",
                "type": "LazyList a -> List a"
            },
            {
                "name": "unique",
                "comment": "Remove all duplicates from a list and return a list of distinct elements.",
                "type": "LazyList a -> LazyList a"
            },
            {
                "name": "zip",
                "comment": "",
                "type": "LazyList a -> LazyList b -> LazyList ( a, b )"
            },
            {
                "name": "zip3",
                "comment": "",
                "type": "LazyList a -> LazyList b -> LazyList c -> LazyList ( a, b, c )"
            },
            {
                "name": "zip4",
                "comment": "",
                "type": "LazyList a -> LazyList b -> LazyList c -> LazyList d -> LazyList ( a, b, c, d )"
            },
            {
                "name": "zip5",
                "comment": "",
                "type": "LazyList a -> LazyList b -> LazyList c -> LazyList d -> LazyList e -> LazyList ( a, b, c, d, e )"
            }
        ],
        "binops": [
            {
                "name": "+++",
                "comment": "Alias for `append`. Analogous to `++` for lists.",
                "type": "LazyList a -> LazyList a -> LazyList a",
                "associativity": "right",
                "precedence": 5
            },
            {
                "name": ":::",
                "comment": "Alias for `cons`. Analogous to `::` for lists.",
                "type": "a -> LazyList a -> LazyList a",
                "associativity": "right",
                "precedence": 5
            }
        ]
    }
]