[{"name":"Data.Function","comment":" Small but handy combinators for building and transforming functions.\n\nThese helpers make it easy to compose complex behaviour on the spot,\nso you can avoid writing ad‑hoc lambdas or intermediate definitions.\n\n@docs id, const, flip, on, applyWhen, fix\n\n","unions":[],"aliases":[],"values":[{"name":"applyWhen","comment":" Apply the function to the value only when the first argument is `True`\notherwise return the value unchanged.\n","type":"Basics.Bool -> (a -> a) -> a -> a"},{"name":"const","comment":" Return the first argument, ignoring the second.\n","type":"a -> b -> a"},{"name":"fix","comment":" The least fixed point of the function f, i.e. the least defined x\nsuch that f x = x.\n\n\n## Examples\n\n    fix\n        (\\rec n ->\n            if n <= 1 then\n                1\n\n            else\n                n * rec (n - 1)\n        )\n        5\n        == 120\n\n    map\n        (fix\n            (\\rec n ->\n                if n < 2 then\n                    n\n\n                else\n                    rec (n - 1) + rec (n - 2)\n            )\n        )\n        (range 1 10)\n        == [ 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 ]\n\n","type":"((a -> b) -> a -> b) -> a -> b"},{"name":"flip","comment":" Return a new function whose first two arguments are swapped.\n","type":"(a -> b -> c) -> b -> a -> c"},{"name":"id","comment":" Return the given value unchanged.\n","type":"a -> a"},{"name":"on","comment":" Apply a projection to two values and then combine the results with the given binary function.\n\nEquivalent to `\\x y -> f (p x) (p y)`.\n\n","type":"(b -> b -> c) -> (a -> b) -> a -> a -> c"}],"binops":[]},{"name":"Data.List","comment":" An extended toolbox for working with lists: everything from the `elm/core`\n`List` module plus Haskell-inspired helpers such as `nub`, `intercalate`, and\n`groupBy`, all implemented the Elm way.\n\n\n# Definition\n\n[List](https://package.elm-lang.org/packages/elm/core/1.0.5/List)\n\n\n# Basic functions\n\n@docs append, head, last, tail, init, uncons, unsnoc, singleton, null, isEmpty, length, compareLength\n\n\n# List transformations\n\n@docs map, map2, map3, map4, map5, indexedMap, reverse, intersperse, intercalate, transpose, subsequences, permutations, filterMap\n\n\n# Reducing lists\n\n@docs foldl, foldr\n\n\n# Special folds\n\n@docs concat, concatMap, and, or, any, all, sum, product, maximum, minimum\n\n\n# Building lists (Scans)\n\n@docs scanl, scanr\n\n\n# Building lists (Accumulating maps)\n\n@docs mapAccumL, mapAccumR\n\n\n# Building lists (infinite lists)\n\n@docs iterate, repeat, range, replicate\n\n\n# Building lists (Unfolding)\n\n@docs unfoldr\n\n\n# Sublists (Extracting sublists)\n\n@docs take, drop, splitAt, takeWhile, dropWhile, dropWhileEnd, span, break, stripPrefix, group, inits, tails\n\n\n# Sublists (Predicates)\n\n@docs isPrefixOf, isSuffixOf, isInfixOf, isSubsequenceOf\n\n\n# Searching lists (Searching by equality)\n\n@docs elem, notElem, lookup, member\n\n\n# Searching lists (Searching with a predicate)\n\n@docs find, filter, partition\n\n\n# Indexing lists\n\n@docs elemIndex, elemIndices, findIndex, findIndices\n\n\n# Zipping and unzipping lists\n\n@docs zip, zip3, zipWith, zipWith3, unzip, unzip3\n\n\n# Special lists (\"Set\" operations)\n\n@docs nub, delete, deleteFirsts, union, intersect\n\n\n# Special lists (Ordered lists)\n\n@docs sort, sortOn, insert\n\n\n# Generalized functions (The \"By\" operations)\n\n@docs nubBy, deleteBy, deleteFirstsBy, unionBy, intersectBy, groupBy\n\n\n# Generalized functions (User-supplied comparison)\n\n@docs sortBy, sortWith, insertBy, maximumBy, minimumBy\n\n\n# Generalized functions (The \"generic\" operations)\n\n@docs genericLength\n\n","unions":[],"aliases":[],"values":[{"name":"all","comment":" Determine if all elements satisfy some test.\n\n    all isEven [ 2, 4 ] == True\n\n    all isEven [ 2, 3 ] == False\n\n    all isEven [] == True\n\n","type":"(a -> Basics.Bool) -> List.List a -> Basics.Bool"},{"name":"and","comment":" Return the logical conjunction of a list of `Bool`s.\n\nEvaluation of this function stops at the first occurrence of `True`, and the result is `True`.\n\n    and [] == True\n\n    and [ True ] == True\n\n    and [ False ] == False\n\n    and [ True, True, False ] == False\n\n","type":"List.List Basics.Bool -> Basics.Bool"},{"name":"any","comment":" Determine if any elements satisfy some test.\n\n    any isEven [ 2, 3 ] == True\n\n    any isEven [ 1, 3 ] == False\n\n    any isEven [] == False\n\n","type":"(a -> Basics.Bool) -> List.List a -> Basics.Bool"},{"name":"append","comment":" Put two lists together.\n\n    append [ 1, 1, 2 ] [ 3, 5, 8 ] == [ 1, 1, 2, 3, 5, 8 ]\n\n    append [ 'a', 'b' ] [ 'c' ] == [ 'a', 'b', 'c' ]\n\nYou can also use [the `(++)` operator](Basics#++) to append lists.\n\n","type":"List.List a -> List.List a -> List.List a"},{"name":"break","comment":" Return a tuple where first element is longest prefix (possibly empty)\nof xs of elements that do not satisfy p and second element is the remainder of\nthe list:\n\n\n## Properties\n\n    break p\n        == span (not << p)\n        == ( takeWhile (not << p) xs, dropWhile (not << p) xs )\n\n\n## Examples\n\n    break (\\x -> x > 3) [ 1, 2, 3, 4, 1, 2, 3, 4 ] == ( [ 1, 2, 3 ], [ 4, 1, 2, 3, 4 ] )\n\n    break (\\x -> x < 9) [ 1, 2, 3 ] == ( [], [ 1, 2, 3 ] )\n\n    break (\\x -> x > 9) [ 1, 2, 3 ] == ( [ 1, 2, 3 ], [] )\n\n","type":"(a -> Basics.Bool) -> List.List a -> ( List.List a, List.List a )"},{"name":"compareLength","comment":" Compare the length of a list with an integer.\n\nReturn `GT` if the list is longer, `LT` if shorter, `EQ` if equal.\nAny positive-length list is `GT` for a negative integer.\n\n    compareLength [ 1, 2, 3 ] 2 == GT\n\n    compareLength [ 1, 2 ] 2 == EQ\n\n    compareLength [ 1 ] 2 == LT\n\n","type":"List.List a -> Basics.Int -> Basics.Order"},{"name":"concat","comment":" Concatenate a bunch of lists into a single list:\n\n    concat [ [ 1, 2 ], [ 3 ], [ 4, 5 ] ] == [ 1, 2, 3, 4, 5 ]\n\n","type":"List.List (List.List a) -> List.List a"},{"name":"concatMap","comment":" Map a given function onto a list and flatten the resulting lists.\n\n    concatMap f xs == concat (map f xs)\n\n","type":"(a -> List.List b) -> List.List a -> List.List b"},{"name":"delete","comment":" Removes the first occurrence of x from its list argument.\nIt is a special case of deleteBy, which allows the programmer to supply their\nown equality test.\n\n\n## Examples\n\n    delete 'a' (String.toList \"banana\") |> String.fromList == \"bnana\"\n\n    delete \"not\" [ \"haskell\", \"is\", \"not\", \"awesome\" ] == [ \"haskell\", \"is\", \"awesome\" ]\n\n","type":"a -> List.List a -> List.List a"},{"name":"deleteBy","comment":" Behaves like [`delete`](#delete), but takes a user-supplied equality\npredicate.\n\n\n## Examples\n\n    deleteBy (<=) 4 (range 1 10) == [ 1, 2, 3, 5, 6, 7, 8, 9, 10 ]\n\n    deleteBy (/=) 5 [ 5, 5, 4, 3, 5, 2 ] == [ 5, 5, 3, 5, 2 ]\n\n","type":"(a -> a -> Basics.Bool) -> a -> List.List a -> List.List a"},{"name":"deleteFirsts","comment":" List difference (non-associative). In the result of delete xs ys, the\nfirst occurrence of each element of ys in turn (if any) has been removed\nfrom xs. Thus `delete (xs ++ ys) xs == ys`.\n\nIt is a special case of [`deleteFirstsBy`](#deleteFirstsBy), which allows the\nprogrammer to supply their own equality test.\n\n\n## Examples\n\n    delete (String.toList \"Hello World!\") (String.toList \"ell W\")\n        |> String.fromList\n        == \"Hoorld!\"\n\n","type":"List.List a -> List.List a -> List.List a"},{"name":"deleteFirstsBy","comment":" Return the first list with the first occurrence of each element of\nthe second list removed.\n\n\n## Properties\n\n    deleteFirsts == deleteFirstsBy (==)\n\n\n## Examples\n\n    deleteFirstsBy (>) (range 1 10) [ 3, 4, 5 ] == [ 4, 5, 6, 7, 8, 9, 10 ]\n\n    deleteFirstsBy (/=) (range 1 10) [ 1, 3, 5 ] == [ 4, 5, 6, 7, 8, 9, 10 ]\n\n","type":"(a -> a -> Basics.Bool) -> List.List a -> List.List a -> List.List a"},{"name":"drop","comment":" Drop the first _n_ members of a list.\n\n    drop 2 [ 1, 2, 3, 4 ] == [ 3, 4 ]\n\n","type":"Basics.Int -> List.List a -> List.List a"},{"name":"dropWhile","comment":" Return the suffix remaining after [`takeWhile`](#takeWhile)\n\n\n## Examples\n\n    dropWhile (\\x -> x < 3) [ 1, 2, 3, 4, 5, 1, 2, 3 ] == [ 3, 4, 5, 1, 2, 3 ]\n\n    dropWhile (\\x -> x < 9) [ 1, 2, 3 ] == []\n\n    dropWhile (\\x -> x < 0) [ 1, 2, 3 ] == [ 1, 2, 3 ]\n\n","type":"(a -> Basics.Bool) -> List.List a -> List.List a"},{"name":"dropWhileEnd","comment":" Drops the largest suffix of a list in which the given predicate holds for\nall elements.\n\n\n## Examples\n\n    let\n        isSpace c =\n            0x09 <= Char.toCode c && Char.toCode c <= 0x0D\n    in\n    dropWhileEnd isSpace (String.toList \"foo\\n\") == String.toList \"foo\"\n\n    let\n        isSpace c =\n            0x09 <= Char.toCode c && Char.toCode c <= 0x0D\n    in\n    dropWhileEnd isSpace (String.toList \"foo bar\") == String.toList \"foo bar\"\n\n    dropWhileEnd (\\x -> x > 10) (List.range 1 20) == [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]\n\n","type":"(a -> Basics.Bool) -> List.List a -> List.List a"},{"name":"elem","comment":" Does the element occur in the structure?\n\nNote:\n\n    elem is often used in infix form.\n\n\n## Examples\n\n    elem 3 [] == False\n\n    elem 3 [ 1, 2 ] == False\n\n    elem 3 [ 1, 2, 3, 4, 5 ] == True\n\n","type":"a -> List.List a -> Basics.Bool"},{"name":"elemIndex","comment":" Return the index of the first element in the given list which is equal to\nthe query element, or `Nothing` if there is no such element.\n\n\n## Examples\n\n    elemIndex 4 (range 0 10) == Just 4\n\n    elemIndex 'o' (String.toList \"haskell\") == Nothing\n\n","type":"a -> List.List a -> Maybe.Maybe Basics.Int"},{"name":"elemIndices","comment":" Return the indicies of all elements equal to the query element, in\nascending order.\n\n\n## Examples\n\n    elemIndices 'o' (String.toList \"Hello World\") == [ 4, 7 ]\n\n    elemIndices 1 [ 1, 2, 3, 1, 2, 3 ] == [ 0, 3 ]\n\n","type":"a -> List.List a -> List.List Basics.Int"},{"name":"filter","comment":" Keep elements that satisfy the test.\n\n    filter isEven [ 1, 2, 3, 4, 5, 6 ] == [ 2, 4, 6 ]\n\n","type":"(a -> Basics.Bool) -> List.List a -> List.List a"},{"name":"filterMap","comment":" Filter out certain values. For example, maybe you have a bunch of strings\nfrom an untrusted source and you want to turn them into numbers:\n\n\n    numbers : List Int\n    numbers =\n        filterMap String.toInt [ \"3\", \"hi\", \"12\", \"4th\", \"May\" ]\n\n    -- numbers == [3, 12]\n\n","type":"(a -> Maybe.Maybe b) -> List.List a -> List.List b"},{"name":"find","comment":" Return the leftmost element of the list matching the predicate,\nor `Nothing` if there is no such element.\n\n\n## Examples\n\n    find (\\x -> x > 42) [ 5, 10, 15, 20, 25, 30, 35, 40, 45, 50 ] == Just 45\n\n    find (\\x -> x > 12) (range 1 7) == Nothing\n\n","type":"(a -> Basics.Bool) -> List.List a -> Maybe.Maybe a"},{"name":"findIndex","comment":" Return the index of the first element in the list satisfying the predicate,\nor `Nothing` if there is no such element.\n\n\n## Examples\n\n    let\n        isSpace c =\n            0x09 <= Char.toCode c && Char.toCode c <= 0x0D\n    in\n    findIndex isSpace (String.toList \"Hello World!\") == Just 5\n\n    findIndex ((/=) 0 << modBy 2) [ 0, 2, 4, 6 ] == Nothing\n\n    findIndex ((==) 0 << modBy 2) [ 1, 2, 3, 4 ] == Just 1\n\n","type":"(a -> Basics.Bool) -> List.List a -> Maybe.Maybe Basics.Int"},{"name":"findIndices","comment":" Extends `findIndex`, by returning the indices of all elements satisfying\nthe predicate, in ascending order.\n\n\n## Examples\n\n    findIndices (\\x -> elem x (String.toList \"aeiou\"))\n        (String.toList \"Hello World!\")\n        == [ 1, 4, 7 ]\n\n    findIndices (\\l -> String.length l > 3)\n        [ \"a\", \"bcde\", \"fgh\", \"ijklmnop\" ]\n        == [ 1, 3 ]\n\n","type":"(a -> Basics.Bool) -> List.List a -> List.List Basics.Int"},{"name":"foldl","comment":" Reduce a list from the left.\n\n    foldl (+) 0 [ 1, 2, 3 ] == 6\n\n    foldl (::) [] [ 1, 2, 3 ] == [ 3, 2, 1 ]\n\nSo `foldl step state [1,2,3]` is like saying:\n\n    state\n        |> step 1\n        |> step 2\n        |> step 3\n\n","type":"(a -> b -> b) -> b -> List.List a -> b"},{"name":"foldr","comment":" Reduce a list from the right.\n\n    foldr (+) 0 [ 1, 2, 3 ] == 6\n\n    foldr (::) [] [ 1, 2, 3 ] == [ 1, 2, 3 ]\n\nSo `foldr step state [1,2,3]` is like saying:\n\n    state\n        |> step 3\n        |> step 2\n        |> step 1\n\n","type":"(a -> b -> b) -> b -> List.List a -> b"},{"name":"genericLength","comment":" An overloaded version of `length`. In particular, instead of returning an\n`Int`, it returns `Float` type.\n\n\n## Examples\n\n    (genericLength [ 1, 2, 3 ] == 3) == True\n\n    (genericLength [ 1, 2, 3 ] == 3.0) == True\n\n","type":"List.List a -> number"},{"name":"group","comment":" Return a list of lists such that the concatenation of the result is equal\nto the argument. Moreover, each sublist in the result is non-empty,\nall elements are equal to the first one, and consecutive equal\nelements of the input end up in the same element of the output list.\n\n`group` is a special case of [`groupBy`](#groupBy), which allows the programmer to supply\ntheir own equality test.\n\n\n## Examples\n\n    group (String.toList \"Mississippi\")\n        |> map String.fromList\n        == [ \"M\", \"i\", \"ss\", \"i\", \"ss\", \"i\", \"pp\", \"i\" ]\n\n    group [ 1, 1, 1, 2, 2, 3, 4, 5, 5 ] == [ [ 1, 1, 1 ], [ 2, 2 ], [ 3 ], [ 4 ], [ 5, 5 ] ]\n\n","type":"List.List a -> List.List (List.List a)"},{"name":"groupBy","comment":" Group adjacent elements according to the given equality function.\n\nWhen a supplied relation is not transitive, it is important to remember that\nequality is checked against the first element in the group, not against the\nnearest neighbour:\n\n    groupBy (\\a b -> b - a < 5) (range 0 19)\n        == [ [ 0, 1, 2, 3, 4 ]\n           , [ 5, 6, 7, 8, 9 ]\n           , [ 10, 11, 12, 13, 14 ]\n           , [ 15, 16, 17, 18, 19 ]\n           ]\n\n\n## Examples\n\n    groupBy (/=) [1, 1, 1, 2, 3, 1, 4, 4, 5\n        == [[1],[1],[1,2,3],[1,4,4,5]]\n\n    groupBy (>) [1, 3, 5, 1, 4, 2, 6, 5, 4]\n        == [[1],[3],[5,1,4,2],[6,5,4]]\n\n    groupBy (const not) [True, False, True, False, False, False, True]\n        == [[True,False],[True,False,False,False],[True]]\n\n","type":"(a -> a -> Basics.Bool) -> List.List a -> List.List (List.List a)"},{"name":"head","comment":" Extract the first element of a list.\n\n    head [ 1, 2, 3 ] == Just 1\n\n    head [] == Nothing\n\n","type":"List.List a -> Maybe.Maybe a"},{"name":"indexedMap","comment":" Same as `map` but the function is also applied to the index of each\nelement (starting at zero).\n\n    indexedMap Tuple.pair [ \"Tom\", \"Sue\", \"Bob\" ] == [ ( 0, \"Tom\" ), ( 1, \"Sue\" ), ( 2, \"Bob\" ) ]\n\n","type":"(Basics.Int -> a -> b) -> List.List a -> List.List b"},{"name":"init","comment":" Return all but the last element of a list.\nIf the list is non-empty, returns `Just` the leading elements (possibly `[]` for a single-element list).\nIf the list is empty, returns `Nothing`.\n\n    init [ 1, 2, 3 ] == Just [ 1, 2 ]\n\n    init [ 1 ] == Just []\n\n    init [] == Nothing\n\n","type":"List.List a -> Maybe.Maybe (List.List a)"},{"name":"inits","comment":" Return all initial segments of the argument, shortest first.\ninits is semantically equivalent to\n\n    map reverse . scanl (flip (:)) []\n\n, but under the hood uses a queue to amortize costs of reverse.\n\n\n## Examples\n\n    inits (String.toList \"abc\")\n        |> map String.fromList\n        == [ \"\", \"a\", \"ab\", \"abc\" ]\n\n    inits [] == [ [] ]\n\n","type":"List.List a -> List.List (List.List a)"},{"name":"insert","comment":" Inserts an element into a list at the first position where it is less\nthan or equal to the next element. In particular, if the list is sorted\nbefore the call, the result will also be sorted. It is a special case of\n[`insertBy`](#insertBy), which allows the programmer to supply their own\ncomparison function.\n\n\n## Examples\n\n    insert -1 [ 1, 2, 3 ] == [ -1, 1, 2, 3 ]\n\n    insert 'd' (String.toList \"abcefg\") == String.toList \"abcdefg\"\n\n    insert 4 [ 1, 2, 3, 5, 6, 7 ] == [ 1, 2, 3, 4, 5, 6, 7 ]\n\n","type":"comparable -> List.List comparable -> List.List comparable"},{"name":"insertBy","comment":" Insert a value into a list using the given ordering function.\n\n\n## Examples\n\n    insertBy (\\x y -> compare (length x) (length y))\n        [ 1, 2 ]\n        [ [ 1 ], [ 1, 2, 3 ], [ 1, 2, 3, 4 ] ]\n        == [ [ 1 ], [ 1, 2 ], [ 1, 2, 3 ], [ 1, 2, 3, 4 ] ]\n\n","type":"(a -> a -> Basics.Order) -> a -> List.List a -> List.List a"},{"name":"intercalate","comment":" Concatenates the lists in the second argument, inserting the first argument\nbetween each adjacent pair.\n\n    intercalate [ 0, 1 ] [ [ 2, 3 ], [ 4, 5, 6 ], [] ] == [ 2, 3, 0, 1, 4, 5, 6, 0, 1 ]\n\n    intercalate [ 1, 2, 3 ] [ [], [] ] == [ 1, 2, 3 ]\n\n    let\n        s =\n            String.toList\n    in\n    intercalate (s \", \") [ s \"Lorem\", s \"ipsum\", s \"dolor\" ]\n        == s \"Lorem, ipsum, dolor\"\n\n","type":"List.List a -> List.List (List.List a) -> List.List a"},{"name":"intersect","comment":" Takes the list intersection of two lists. It is a special case of\n[`intersectBy`](#intersectBy), which allows the programmer to supply their own\nequality test.\n\n\n## Examples\n\n    intersect [ 1, 2, 3, 4 ] [ 2, 4, 6, 8 ] == [ 2, 4 ]\n\nIf equal elements are present in both lists, an element from the first list\nwill be used, and all duplicates from the second list quashed:\n\n    intersect [ 1, 1, 2 ] [ 1, 2, 3 ] == [ 1, 1, 2 ]\n\nHowever if the first list contains duplicates, so will the result.\n\n    intersect (String.toList \"coot\") (String.toList \"heron\")\n        |> String.fromList\n        == \"oo\"\n\n    intersect (String.toList \"heron\") (String.toList \"coot\")\n        |> String.fromList\n        == \"o\"\n\n","type":"List.List a -> List.List a -> List.List a"},{"name":"intersectBy","comment":" Return the list intersection of two lists using given equality function.\n\nIf equal elements are present in both lists, an element from the first list\nwill be used, and all duplicates from the second list quashed:\n\n    type Arg a b = Arg a b\n    eq (Arg a1 b1) (Arg a2 b2) = a1 == a2\n    intersect [Arg () \"dog\"] [Arg () \"cow\", Arg () \"cat\"] == [Arg () \"dog\"]\n\n","type":"(a -> a -> Basics.Bool) -> List.List a -> List.List a -> List.List a"},{"name":"intersperse","comment":" Places the given value between all members of the given list.\n\n    intersperse \"on\" [ \"turtles\", \"turtles\", \"turtles\" ] == [ \"turtles\", \"on\", \"turtles\", \"on\", \"turtles\" ]\n\n","type":"a -> List.List a -> List.List a"},{"name":"isEmpty","comment":" Determine if a list is empty.\n\n    isEmpty [] == True\n\n","type":"List.List a -> Basics.Bool"},{"name":"isInfixOf","comment":" Takes two lists and returns `True` iff the first list is contained,\nwholly and intact, anywhere within the second.\n\n\n## Examples\n\n    isInfixOf (String.toList \"Haskell\")\n        (String.toList \"I really like Haskell.\")\n        == True\n\n    isInfixOf (String.toList \"Ial\")\n        (String.toList \"I really like Haskell.\")\n        == False\n\n","type":"List.List a -> List.List a -> Basics.Bool"},{"name":"isPrefixOf","comment":" Takes two lists and returns True iff the first list is a prefix of the\nsecond.\n\n\n## Examples\n\n    isPrefixOf (String.toList \"Hello\") (String.toList \"Hello World!\") == True\n\n    isPrefixOf (String.toList \"Hello\") (String.toList \"Wello Horld!\") == False\n\nisPrefixOf shortcuts when the first argument is empty:\n\n    forall x, isPrefixOf [] x == True\n\n","type":"List.List a -> List.List a -> Basics.Bool"},{"name":"isSubsequenceOf","comment":" Return `True` if all the elements of the first list occur, in order,\nin the second. The elements do not have to occur consecutively.\n\n\n## Properties\n\n    isSubsequenceOf x y == elem x (subsequences y)\n\nNote:\n\n    isSubsequenceOf is often used in infix form.\n\n\n## Examples\n\n    isSubsequenceOf (String.toList \"GHC\")\n        (String.toList \"The Glorious Haskell Compiler\") == True\n    isSubsequenceOf ['a'..'z'] == True\n    isSubsequenceOf [1..10] [10,9..0] == False\n\n","type":"List.List a -> List.List a -> Basics.Bool"},{"name":"isSuffixOf","comment":" Takes two lists and returns `True` iff the first\nlist is a suffix of the second.\n\n\n## Examples\n\n    isSuffixOf (String.toList \"ld!\") (String.toList \"Hello World!\") == True\n\n    isSuffixOf (String.toList \"World\") (String.toList \"Hello World!\") == False\n\n","type":"List.List a -> List.List a -> Basics.Bool"},{"name":"iterate","comment":" `n` repeated applications `f` to `x`\n\n\n## Properties\n\n    iterate n f x == [x, f x, f (f x), ...]\n\n\n## Examples\n\n    iterate 3 ((+) 1) 0 == [ 0, 1, 2 ]\n\n","type":"Basics.Int -> (a -> a) -> a -> List.List a"},{"name":"last","comment":" Get the last element of a list. Return `Just` the element if the list is\nnon-empty, or `Nothing` when the list is empty.\n\n    last [ 1, 2, 3 ] == Just 3\n\n    last [] == Nothing\n\n","type":"List.List a -> Maybe.Maybe a"},{"name":"length","comment":" Determine the length of a list.\n\n    length [ 1, 2, 3 ] == 3\n\n","type":"List.List a -> Basics.Int"},{"name":"lookup","comment":" Looks up the value associated with the key in an association list.\n\n\n## Examples\n\n    lookup 2 [] == Nothing\n\n    lookup 2 [ ( 1, \"first\" ) ] == Nothing\n\n    lookup 2 [ ( 1, \"first\" ), ( 2, \"second\" ), ( 3, \"third\" ) ]\n        == Just \"second\"\n\n","type":"a -> List.List ( a, b ) -> Maybe.Maybe b"},{"name":"map","comment":" Apply a function to every element of a list.\n\n    map sqrt [ 1, 4, 9 ] == [ 1, 2, 3 ]\n\n    map not [ True, False, True ] == [ False, True, False ]\n\nSo `map func [ a, b, c ]` is the same as `[ func a, func b, func c ]`\n\n","type":"(a -> b) -> List.List a -> List.List b"},{"name":"map2","comment":" Combine two lists, combining them with the given function.\nIf one list is longer, the extra elements are dropped.\n\n\n    totals : List Int -> List Int -> List Int\n    totals xs ys =\n        List.map2 (+) xs ys\n\n    -- totals [1,2,3] [4,5,6] == [5,7,9]\n    pairs : List a -> List b -> List ( a, b )\n    pairs xs ys =\n        List.map2 Tuple.pair xs ys\n\n    -- pairs [\"alice\",\"bob\",\"chuck\"] [2,5,7,8]\n    --   == [(\"alice\",2),(\"bob\",5),(\"chuck\",7)]\n\n","type":"(a -> b -> result) -> List.List a -> List.List b -> List.List result"},{"name":"map3","comment":" ","type":"(a -> b -> c -> result) -> List.List a -> List.List b -> List.List c -> List.List result"},{"name":"map4","comment":" ","type":"(a -> b -> c -> d -> result) -> List.List a -> List.List b -> List.List c -> List.List d -> List.List result"},{"name":"map5","comment":" ","type":"(a -> b -> c -> d -> e -> result) -> List.List a -> List.List b -> List.List c -> List.List d -> List.List e -> List.List result"},{"name":"mapAccumL","comment":" Behaves like a combination of [`map`](#map) and [`foldl`](#foldl); it applies a function to\neach element of a list, passing an accumulating parameter from left to right,\nand returning a final value of this accumulator together with the new list.\n\n    mapAccumL (\\a b -> ( a + b, a )) 0 (range 1 10)\n        == ( 55, [ 0, 1, 3, 6, 10, 15, 21, 28, 36, 45 ] )\n\n    mapAccumL (\\a b -> ( a ++ String.fromInt b, a )) \"0\" (range 1 5)\n        == ( \"012345\", [ \"0\", \"01\", \"012\", \"0123\", \"01234\" ] )\n\n","type":"(s -> a -> ( s, b )) -> s -> List.List a -> ( s, List.List b )"},{"name":"mapAccumR","comment":" Behaves like a combination of [`map`](#map) and [`foldr`](#foldr); it applies a function to\neach element of a list, passing an accumulating parameter from right to left,\nand returning a final value of this accumulator together with the new list.\n\n    mapAccumR (\\a b -> ( a + b, a )) 0 (range 1 10)\n        == ( 55, [ 54, 52, 49, 45, 40, 34, 27, 19, 10, 0 ] )\n\n    mapAccumR (\\a b -> ( a ++ String.fromInt b, a )) \"0\" (range 1 5)\n        == ( \"054321\", [ \"05432\", \"0543\", \"054\", \"05\", \"0\" ] )\n\n","type":"(s -> a -> ( s, b )) -> s -> List.List a -> ( s, List.List b )"},{"name":"maximum","comment":" Find the maximum element in a non-empty list.\n\n    maximum [ 1, 4, 2 ] == Just 4\n\n    maximum [] == Nothing\n\n","type":"List.List comparable -> Maybe.Maybe comparable"},{"name":"maximumBy","comment":" The largest element of a list if exists with respect to the given\ncomparison function. If there are multiple largest elements, the rightmost\nof them is chosen.\n\n\n## Examples\n\n    maximumBy (\\x y -> compare (String.length x) (String.length y))\n        [ \"Hello\", \"World\", \"!\", \"Longest\", \"bar\" ]\n        == Just \"Longest\"\n\n","type":"(a -> a -> Basics.Order) -> List.List a -> Maybe.Maybe a"},{"name":"member","comment":" Figure out whether a list contains a value.\n\n    member 9 [ 1, 2, 3, 4 ] == False\n\n    member 4 [ 1, 2, 3, 4 ] == True\n\n","type":"a -> List.List a -> Basics.Bool"},{"name":"minimum","comment":" Find the minimum element in a non-empty list.\n\n    minimum [ 3, 2, 1 ] == Just 1\n\n    minimum [] == Nothing\n\n","type":"List.List comparable -> Maybe.Maybe comparable"},{"name":"minimumBy","comment":" The least element of a list if exists with respect to the given\ncomparison function. If there are multiple least elements, the leftmost\nof them is chosen.\n\n\n## Examples\n\n    minimumBy (\\x y -> compare (String.length x) (String.length y))\n        [ \"Hello\", \"World\", \"!\", \"Longest\", \"bar\" ]\n        == Just \"!\"\n\n","type":"(a -> a -> Basics.Order) -> List.List a -> Maybe.Maybe a"},{"name":"notElem","comment":" The negation of `elem`.\n\n\n## Examples\n\n    notElem 3 [] == True\n\n    notElem 3 [ 1, 2 ] == True\n\n    notElem 3 [ 1, 2, 3, 4, 5 ] == False\n\n","type":"a -> List.List a -> Basics.Bool"},{"name":"nub","comment":" Remove duplicate elements from a list. In particular, it keeps only the\nfirst occurrence of each element. (The name nub means \\`essence'.)\n\nThis is a special case of [`nubBy`](#nubBy), which allows the programmer to\nsupply their own equality test.\n\nPerformance: `nub` runs in _O(n^2)_ time because it compares each element with\nall preceding ones. If you do not need to preserve the original order and\nelements are `comparable`, you can get _O(nlogn)_ with:\n\n    filterMap head << group << sort`\n\nThe result will be sorted rather than in the original order.\n\n\n## Examples\n\n    nub [ 1, 2, 3, 4, 3, 2, 1, 2, 4, 3, 5 ] == [ 1, 2, 3, 4, 5 ]\n\n    nub (String.toList \"hello, world!\") == String.toList \"helo, wrd!\"\n\n","type":"List.List a -> List.List a"},{"name":"nubBy","comment":" Behaves just like `nub`, except it uses a user-supplied equality predicate.\n\n\n## Examples\n\n    nubBy (\\x y -> modBy 3 x == modBy 3 y) [ 1, 2, 4, 5, 6 ] == [ 1, 2, 6 ]\n\n    nubBy (/=) [ 2, 7, 1, 8, 2, 8, 1, 8, 2, 8 ] == [ 2, 2, 2 ]\n\n    nubBy (>) [ 1, 2, 3, 2, 1, 5, 4, 5, 3, 2 ] == [ 1, 2, 3, 5, 5 ]\n\n","type":"(a -> a -> Basics.Bool) -> List.List a -> List.List a"},{"name":"null","comment":" Determine whether a list is empty.\n\n    null [] == True\n\n    null [ 1 ] == False\n\nAlias of [`isEmpty`](#isEmpty).\n\n","type":"List.List a -> Basics.Bool"},{"name":"or","comment":" Return the logical disjunction of a list of `Bool`s.\n\nEvaluation of this function stops at the first occurrence of `True`, and the result is `True`.\n\n    or [] == False\n\n    or [ False ] == False\n\n    or [ True ] == True\n\n    or [ True, True, False ] == True\n\n","type":"List.List Basics.Bool -> Basics.Bool"},{"name":"partition","comment":" Partition a list based on some test. The first list contains all values\nthat satisfy the test, and the second list contains all the value that do not.\n\n    partition (\\x -> x < 3) [ 0, 1, 2, 3, 4, 5 ] == ( [ 0, 1, 2 ], [ 3, 4, 5 ] )\n\n    partition isEven [ 0, 1, 2, 3, 4, 5 ] == ( [ 0, 2, 4 ], [ 1, 3, 5 ] )\n\n","type":"(a -> Basics.Bool) -> List.List a -> ( List.List a, List.List a )"},{"name":"permutations","comment":" Return the list of all permutations of the argument.\nNote that the order of permutations is not lexicographic.\n\n\n## Properties\n\n    map (take n)\n        (take (product (List.range 1 n)) (permutations (List.range 1 n)))\n        == permutations (range 1 n)\n\n\n## Examples\n\n    permutations [ 1, 2 ] == [ [ 1, 2 ], [ 2, 1 ] ]\n\n    permutations [] == [ [] ]\n\n    let\n        s =\n            String.toList\n    in\n    permutations \"abc\" == [ \"abc\", \"bac\", \"cba\", \"bca\", \"cab\", \"acb\" ]\n\n","type":"List.List a -> List.List (List.List a)"},{"name":"product","comment":" Get the product of the list elements.\n\n    product [ 2, 2, 2 ] == 8\n\n    product [ 3, 3, 3 ] == 27\n\n    product [] == 1\n\n","type":"List.List number -> number"},{"name":"range","comment":" Create a list of numbers, every element increasing by one.\nYou give the lowest and highest number that should be in the list.\n\n    range 3 6 == [ 3, 4, 5, 6 ]\n\n    range 3 3 == [ 3 ]\n\n    range 6 3 == []\n\n","type":"Basics.Int -> Basics.Int -> List.List Basics.Int"},{"name":"repeat","comment":" Create a list with _n_ copies of a value:\n\n    repeat 3 ( 0, 0 ) == [ ( 0, 0 ), ( 0, 0 ), ( 0, 0 ) ]\n\n","type":"Basics.Int -> a -> List.List a"},{"name":"replicate","comment":" Alias to [`repeat`](#repeat)\n","type":"Basics.Int -> a -> List.List a"},{"name":"reverse","comment":" Reverse a list.\n\n    reverse [ 1, 2, 3, 4 ] == [ 4, 3, 2, 1 ]\n\n","type":"List.List a -> List.List a"},{"name":"scanl","comment":" The list of successive reduced values from the left.\n\n    scanl f z [x1, x2, ...] == [z, f x1 z, f x2 (f x1 z), ...]\n\n\n## Properties\n\n    last (scanl f z xs) == foldl f z xs\n\n\n## Examples\n\n    scanl (+) 0 (List.range 1 4) == [ 0, 1, 3, 6, 10 ]\n\n    scanl (+) 42 [] == [ 42 ]\n\n    scanl (-) 100 (List.range 1 4) == [ 100, 99, 97, 94, 90 ]\n\n    scanl String.cons \"foo\" [ 'a', 'b', 'c', 'd' ]\n        == [ \"foo\", \"afoo\", \"bafoo\", \"cbafoo\", \"dcbafoo\" ]\n\n    scanl (+) 0 (range 1 10) == [ 0, 1, 3, 6, 10, 15, 21, 28, 36, 45 ]\n\n","type":"(a -> b -> b) -> b -> List.List a -> List.List b"},{"name":"scanr","comment":" The right-to-left dual of scanl. Note that the order of parameters on the\naccumulating function are reversed compared to scanl. Also note that\n\n    head (scanr f z xs) == foldr f z xs.\n\n\n## Examples\n\n    scanr (+) 0 (List.range 1 4) == [ 10, 9, 7, 4, 0 ]\n\n    scanr (+) 42 [] == [ 42 ]\n\n    scanr (-) 100 (List.range 1 4) == [ 98, -97, 99, -96, 100 ]\n\n    scanr String.cons \"foo\" [ 'a', 'b', 'c', 'd' ]\n        == [ \"abcdfoo\", \"bcdfoo\", \"cdfoo\", \"dfoo\", \"foo\" ]\n\n","type":"(a -> b -> b) -> b -> List.List a -> List.List b"},{"name":"singleton","comment":" Create a list with only one element\n","type":"a -> List.List a"},{"name":"sort","comment":" Sort values from lowest to highest\n\n    sort [ 3, 1, 5 ] == [ 1, 3, 5 ]\n\n","type":"List.List comparable -> List.List comparable"},{"name":"sortBy","comment":" Sort values by a derived property.\n\n    alice = { name=\"Alice\", height=1.62 }\n    bob   = { name=\"Bob\"  , height=1.85 }\n    chuck = { name=\"Chuck\", height=1.76 }\n\n    sortBy .name   [chuck,alice,bob] == [alice,bob,chuck]\n    sortBy .height [chuck,alice,bob] == [alice,chuck,bob]\n\n    sortBy String.length [\"mouse\",\"cat\"] == [\"cat\",\"mouse\"]\n\n","type":"(a -> a -> Basics.Order) -> List.List a -> List.List a"},{"name":"sortOn","comment":" Sort a list by comparing the results of a key function applied to\neach element. `sortOn f` is equivalent to\n`sortBy (\\x y -> compare (f x) (f y))`, but has the performance advantage of\nonly evaluating f once for each element in the input list. This is called the\ndecorate-sort-undecorate paradigm, or Schwartzian transform.\n\nElements are arranged from lowest to highest, keeping duplicates in the\norder they appeared in the input.\n\n\n## Examples\n\n    sortOn Tuple.first [ ( 2, \"world\" ), ( 4, \"!\" ), ( 1, \"Hello\" ) ]\n        == [ ( 1, \"Hello\" ), ( 2, \"world\" ), ( 4, \"!\" ) ]\n\n    sortOn String.length [ \"jim\", \"creed\", \"pam\", \"michael\", \"dwight\", \"kevin\" ]\n        == [ \"jim\", \"pam\", \"creed\", \"kevin\", \"dwight\", \"michael\" ]\n\n","type":"(a -> comparable) -> List.List a -> List.List a"},{"name":"sortWith","comment":" Sort values with a custom comparison function.\n\n    sortWith flippedComparison [1,2,3,4,5] == [5,4,3,2,1]\n\n    flippedComparison a b =\n        case compare a b of\n          LT -> GT\n          EQ -> EQ\n          GT -> LT\n\nThis is also the most general sort function, allowing you\nto define any other: `sort == sortWith compare`\n\n","type":"(a -> a -> Basics.Order) -> List.List a -> List.List a"},{"name":"span","comment":" Return a tuple where first element is the longest prefix (possibly empty)\nof xs of elements that satisfy p and second element is the remainder of the\nlist.\n\n\n## Examples\n\n    span (\\x -> x < 3) [ 1, 2, 3, 4, 1, 2, 3, 4 ] == ( [ 1, 2 ], [ 3, 4, 1, 2, 3, 4 ] )\n\n    span (\\x -> x < 9) [ 1, 2, 3 ] == ( [ 1, 2, 3 ], [] )\n\n    span (\\x -> x < 0) [ 1, 2, 3 ] == ( [], [ 1, 2, 3 ] )\n\n","type":"(a -> Basics.Bool) -> List.List a -> ( List.List a, List.List a )"},{"name":"splitAt","comment":" Return a tuple where first element is xs prefix of length n\nand second element is the remainder of the list:\n\n\n## Examples\n\n    splitAt 6 (String.toList \"Hello World!\")\n        == ( String.toList \"Hello \", String.toList \"World!\" )\n\n    splitAt 3 [ 1, 2, 3, 4, 5 ] == ( [ 1, 2, 3 ], [ 4, 5 ] )\n\n    splitAt 1 [ 1, 2, 3 ] == ( [ 1 ], [ 2, 3 ] )\n\n    splitAt 3 [ 1, 2, 3 ] == ( [ 1, 2, 3 ], [] )\n\n    splitAt 4 [ 1, 2, 3 ] == ( [ 1, 2, 3 ], [] )\n\n    splitAt 0 [ 1, 2, 3 ] == ( [], [ 1, 2, 3 ] )\n\n    splitAt -1 [ 1, 2, 3 ] == ( [], [ 1, 2, 3 ] )\n\n","type":"Basics.Int -> List.List a -> ( List.List a, List.List a )"},{"name":"stripPrefix","comment":" Drops the given prefix from a list. It returns Nothing if the list did not\nstart with the prefix given, or Just the list after the prefix, if it does.\n\n\n## Examples\n\n    stripPrefix (String.toList \"foo\") (String.toList \"foobar\")\n        == Just (String.toList \"bar\")\n\n    stripPrefix (String.toList \"foo\") (String.toList \"foo\")\n        == Just (String.toList \"\")\n\n    stripPrefix (String.toList \"foo\") (String.toList \"barfoo\")\n        == Nothing\n\n    stripPrefix (String.toList \"foo\") (String.toList \"barfoobaz\")\n        == Nothing\n\n","type":"List.List a -> List.List a -> Maybe.Maybe (List.List a)"},{"name":"subsequences","comment":" Return the list of all subsequences of the argument.\n\n    let\n        s =\n            String.toList\n    in\n    subsequences (s \"abc\") == map s [ \"\", \"a\", \"b\", \"ab\", \"c\", \"ac\", \"bc\", \"abc\" ]\n\n","type":"List.List a -> List.List (List.List a)"},{"name":"sum","comment":" Get the sum of the list elements.\n\n    sum [ 1, 2, 3 ] == 6\n\n    sum [ 1, 1, 1 ] == 3\n\n    sum [] == 0\n\n","type":"List.List number -> number"},{"name":"tail","comment":" Extract the rest of the list.\n\n    tail [ 1, 2, 3 ] == Just [ 2, 3 ]\n\n    tail [] == Nothing\n\n","type":"List.List a -> Maybe.Maybe (List.List a)"},{"name":"tails","comment":" Return all final segments of the argument, longest first.\n\n\n## Examples\n\n    tails (String.toList \"abc\")\n        |> map String.fromList\n        == [ \"abc\", \"bc\", \"c\", \"\" ]\n\n    tails [ 1, 2, 3 ] == [ [ 1, 2, 3 ], [ 2, 3 ], [ 3 ], [] ]\n\n    tails [] == [ [] ]\n\n","type":"List.List a -> List.List (List.List a)"},{"name":"take","comment":" Take the first _n_ members of a list.\n\n    take 2 [ 1, 2, 3, 4 ] == [ 1, 2 ]\n\n","type":"Basics.Int -> List.List a -> List.List a"},{"name":"takeWhile","comment":" Applied to a predicate p and a list xs, returns the longest\nprefix (possibly empty) of xs of elements that satisfy p.\n\n\n## Examples\n\n    takeWhile (\\x -> x < 3) [ 1, 2, 3, 4, 1, 2, 3, 4 ] == [ 1, 2 ]\n\n    takeWhile (\\x -> x < 9) [ 1, 2, 3 ] == [ 1, 2, 3 ]\n\n    takeWhile (\\x -> x < 0) [ 1, 2, 3 ] == []\n\n","type":"(a -> Basics.Bool) -> List.List a -> List.List a"},{"name":"transpose","comment":" Transpose the rows and columns of the argument list of lists.\n\n    transpose [ [ 1, 2, 3 ], [ 4, 5, 6 ] ] == [ [ 1, 4 ], [ 2, 5 ], [ 3, 6 ] ]\n\nIf some of the rows are shorter than the following rows, their elements are skipped:\n\n    transpose [ [ 10, 11 ], [ 20 ], [], [ 30, 31, 32 ] ] == [ [ 10, 20, 30 ], [ 11, 31 ], [ 32 ] ]\n\n","type":"List.List (List.List a) -> List.List (List.List a)"},{"name":"uncons","comment":" Decompose a list into its first element and the remaining elements.\n\nFor a non-empty list, returns `Just ( x, xs )`.\nFor an empty list, returns `Nothing`.\n\n    uncons [ 1, 2, 3 ] == Just ( 1, [ 2, 3 ] )\n\n    uncons [] == Nothing\n\n","type":"List.List a -> Maybe.Maybe ( a, List.List a )"},{"name":"unfoldr","comment":" A dual to [`foldr`](#foldr): while foldr reduces a list to a summary value,\nunfoldr builds a list from a seed value. The function takes the element\nand returns `Nothing` if it is done producing the list or returns `Just (a,b)`,\nin which case, `a` is a prepended to the list\nand `b` is used as the next element in a recursive call.\n\nIn some cases, unfoldr can undo a foldr operation:\n\n    unfoldr g (foldr f z xs) == xs\n\nif the following holds:\n\n    g (f x y) = Just (x,y)\n    g z       = Nothing\n\nFor example:\n\n    unfoldr\n        (\\b ->\n            if b == 0 then\n                Nothing\n\n            else\n                Just ( b, b - 1 )\n        )\n        10\n        == [ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ]\n\n","type":"(b -> Maybe.Maybe ( a, b )) -> b -> List.List a"},{"name":"union","comment":" Return the list union of the two lists. It is a special case of\n[`unionBy`](#unionBy), which allows the programmer to supply their own\nequality test.\n\n\n## Examples\n\n    union (String.toList \"dog\") (String.toList \"cow\")\n        |> String.fromList\n        == \"dogcw\"\n\nAll elements in the first list are kept including duplicates.\nFrom the second list, each element is added only if it has not appeared\nearlier in the result.\n\n    union (String.toList \"coot\") (String.toList \"duck\")\n        |> String.fromList\n        == \"cootduk\"\n\n    union (String.toList \"duck\") (String.toList \"coot\")\n        |> String.fromList\n        == \"duckot\"\n\n","type":"List.List a -> List.List a -> List.List a"},{"name":"unionBy","comment":" Return the list union of the two lists using given equality function.\n\nIf equal elements are present in both lists, an element from the first list\nwill be used. If the second list contains equal elements, only the first one\nwill be retained:\n\n    type Arg a b = Arg a b\n    eq (Arg a1 b1) (Arg a2 b2) = a1 == a2\n    unionBy eq [Arg () \"dog\"] [Arg () \"cow\"] == [Arg () \"dog\"]\n    unionBy eq [] [Arg () \"dog\", Arg () \"cow\"] == [Arg () \"dog\"]\n\n\n## Examples\n\n    unionBy (>) [ 3, 4, 5 ] [ 1, 2, 3, 4, 5, 6 ] == [ 3, 4, 5, 4, 5, 6 ]\n\n","type":"(a -> a -> Basics.Bool) -> List.List a -> List.List a -> List.List a"},{"name":"unsnoc","comment":" Decompose a list into its initial elements and its last element.\n\nFor a non-empty list, returns `Just ( ys, y )` where `ys ++ [ y ]` reconstructs the original list.\nFor an empty list, returns `Nothing`.\n\n    unsnoc [ 1, 2, 3 ] == Just ( [ 1, 2 ], 3 )\n\n    unsnoc [ 1 ] == Just ( [], 1 )\n\n    unsnoc [] == Nothing\n\n","type":"List.List a -> Maybe.Maybe ( List.List a, a )"},{"name":"unzip","comment":" Decompose a list of tuples into a tuple of lists.\n\n    unzip [ ( 0, True ), ( 17, False ), ( 1337, True ) ] == ( [ 0, 17, 1337 ], [ True, False, True ] )\n\n","type":"List.List ( a, b ) -> ( List.List a, List.List b )"},{"name":"unzip3","comment":" Takes a list of triples and returns three lists of the respective\ncomponents, analogous to [`unzip`](#unzip).\n\n\n## Examples\n\n    unzip3 [] == ( [], [], [] )\n\n    unzip3 [ ( 1, 'a', True ), ( 2, 'b', False ) ]\n        == ( [ 1, 2 ], [ 'a', 'b' ], [ True, False ] )\n\n","type":"List.List ( a, b, c ) -> ( List.List a, List.List b, List.List c )"},{"name":"zip","comment":" Return a list of corresponding pairs.\n\n\n## Examples\n\n    zip [ 1, 2, 3 ] [ 'a', 'b', 'c' ] == [ ( 1, 'a' ), ( 2, 'b' ), ( 3, 'c' ) ]\n\nIf one input list is shorter than the other, excess elements of the longer\nlist are discarded.\n\n    zip [ 1 ] [ 'a', 'b' ] == [ ( 1, 'a' ) ]\n\n    zip [ 1, 2 ] [ 'a' ] == [ ( 1, 'a' ) ]\n\n    zip [] [ 1, 2, 3 ] == []\n\n    zip [ 1, 2, 3 ] [] == []\n\n","type":"List.List a -> List.List b -> List.List ( a, b )"},{"name":"zip3","comment":" Return a list of triples, analogous to [`zip`](#zip).\n","type":"List.List a -> List.List b -> List.List c -> List.List ( a, b, c )"},{"name":"zipWith","comment":" generalises zip by zipping with the function given as the first argument,\ninstead of a tupling function.\n\n    zipWith (,) xs ys == zip xs ys\n    zipWith f [x1,x2,x3..] [y1,y2,y3..] == [f x1 y1, f x2 y2, f x3 y3..]\n\nzipWith is right-lazy:\n\n    let\n        bot () =\n            bot ()\n    in\n    zipWith bot [] [ () ] == []\n\n\n## Examples\n\n    zipWith (+) [ 1, 2, 3 ] [ 4, 5, 6 ] == [ 5, 7, 9 ]\n\n    zipWith (++) [ \"hello \", \"foo\" ] [ \"world!\", \"bar\" ]\n        == [ \"hello world!\", \"foobar\" ]\n\n","type":"(a -> b -> c) -> List.List a -> List.List b -> List.List c"},{"name":"zipWith3","comment":" Combines three elements, as well as three lists and returns a list of the\nfunction applied to corresponding elements, analogous to [`zipWith`](#zipWith).\n\n    zipWith3 (\\x y z -> ( x, y, z )) xs ys zs == zip3 xs ys zs\n\n    zipWith3 f [ x1, x2, x3 ] [ y1, y2, y3 ] [ z1, z2, z3 ]\n        == [ f x1 y1 z1, f x2 y2 z2, f x3 y3 z3 ]\n\n\n## Examples\n\n    zipWith3 (\\x y z -> [ x, y, z ])\n        (String.toList \"123\")\n        (String.toList \"abc\")\n        (String.toList \"xyz\")\n        |> map String.fromList\n        == [ \"1ax\", \"2by\", \"3cz\" ]\n\n    zipWith3 (\\x y z -> (x * y) + z)\n        [ 1, 2, 3 ]\n        [ 4, 5, 6 ]\n        [ 7, 8, 9 ]\n        == [ 11, 18, 27 ]\n\n","type":"(a -> b -> c -> d) -> List.List a -> List.List b -> List.List c -> List.List d"}],"binops":[]},{"name":"Data.Maybe","comment":" An extended toolbox for working with maybes: everything from the `elm/core`\n`Maybe` module plus Haskell-inspired helpers such as `maybe`, `isJust` and\n`maybeToList`, all implemented the Elm way.\n\n\n# Definition\n\n[Maybe](https://package.elm-lang.org/packages/elm/core/1.0.5/Maybe)\n\n\n# Common Helpers\n\n@docs withDefault, fromMaybe, maybe, isJust, isNothing\n\n\n# Maybe transformations\n\n@docs map, map2, map3, map4, map5, listToMaybe, maybeToList, catMaybes, mapMaybe\n\n\n# Chaining Maybes\n\n@docs andThen\n\n","unions":[],"aliases":[],"values":[{"name":"andThen","comment":" Chain together many computations that may fail. It is helpful to see its\ndefinition:\n\n    andThen : (a -> Maybe b) -> Maybe a -> Maybe b\n    andThen callback maybe =\n        case maybe of\n            Just value ->\n                callback value\n\n            Nothing ->\n                Nothing\n\nThis means we only continue with the callback if things are going well. For\nexample, say you need to parse some user input as a month:\n\n    parseMonth : String -> Maybe Int\n    parseMonth userInput =\n        String.toInt userInput\n            |> andThen toValidMonth\n\n    toValidMonth : Int -> Maybe Int\n    toValidMonth month =\n        if 1 <= month && month <= 12 then\n            Just month\n\n        else\n            Nothing\n\nIn the `parseMonth` function, if `String.toInt` produces `Nothing` (because\nthe `userInput` was not an integer) this entire chain of operations will\nshort-circuit and result in `Nothing`. If `toValidMonth` results in `Nothing`,\nagain the chain of computations will result in `Nothing`.\n\n","type":"(a -> Maybe.Maybe b) -> Maybe.Maybe a -> Maybe.Maybe b"},{"name":"catMaybes","comment":" Take a list of Maybes and return a list of all the Just values.\n\n\n## Examples\n\nBasic usage:\n\n    catMaybes [ Just 1, Nothing, Just 3 ] == [ 1, 3 ]\n\nWhen constructing a list of Maybe values, catMaybes can be used to return all of the \"success\" results (if the list is the result of a map, then mapMaybe would be more appropriate):\n\n    catMaybes (map String.toInt [ \"1\", \"Foo\", \"3\" ]) == [ 1, 3 ]\n\n","type":"List.List (Maybe.Maybe a) -> List.List a"},{"name":"fromMaybe","comment":" Provide a default value, turning an optional value into a normal\nvalue.\nAlias of [`withDefault`](#withDefault).\n","type":"a -> Maybe.Maybe a -> a"},{"name":"isJust","comment":" Return True iff its argument is of the form `Just _`.\n\n\n## Examples\n\nBasic usage:\n\n    isJust (Just 3) == True\n\n    isJust (Just ()) == True\n\n    isJust Nothing == False\n\nOnly the outer constructor is taken into consideration:\n\n    isJust (Just Nothing) == True\n\n","type":"Maybe.Maybe a -> Basics.Bool"},{"name":"isNothing","comment":" Return True iff its argument is `Nothing`.\n\n\n## Examples\n\nBasic usage:\n\n    isNothing (Just 3) == False\n\n    isNothing (Just ()) == False\n\n    isNothing Nothing == True\n\nOnly the outer constructor is taken into consideration:\n\n    isNothing (Just Nothing) == False\n\n","type":"Maybe.Maybe a -> Basics.Bool"},{"name":"listToMaybe","comment":" Return `Nothing` on an empty list or `Just a` where a is the first element\nof the list.\n\n\n## Examples\n\nBasic usage:\n\n    listToMaybe [] == Nothing\n\n    listToMaybe [ 9 ] == Just 9\n\n    listToMaybe [ 1, 2, 3 ] == Just 1\n\nComposing maybeToList with listToMaybe should be the identity on\nsingleton/empty lists:\n\n    (maybeToList <| listToMaybe [ 5 ]) == [ 5 ]\n\n    (maybeToList <| listToMaybe []) == []\n\nBut not on lists with more than one element:\n\n    (maybeToList <| listToMaybe [ 1, 2, 3 ]) == [ 1 ]\n\n","type":"List.List a -> Maybe.Maybe a"},{"name":"map","comment":" Transform a `Maybe` value with a given function:\n\n    map sqrt (Just 9) == Just 3\n\n    map sqrt Nothing == Nothing\n\n    map sqrt (String.toFloat \"9\") == Just 3\n\n    map sqrt (String.toFloat \"x\") == Nothing\n\n","type":"(a -> b) -> Maybe.Maybe a -> Maybe.Maybe b"},{"name":"map2","comment":" Apply a function if all the arguments are `Just` a value.\n\n    map2 (+) (Just 3) (Just 4) == Just 7\n\n    map2 (+) (Just 3) Nothing == Nothing\n\n    map2 (+) Nothing (Just 4) == Nothing\n\n    map2 (+) (String.toInt \"1\") (String.toInt \"123\") == Just 124\n\n    map2 (+) (String.toInt \"x\") (String.toInt \"123\") == Nothing\n\n    map2 (+) (String.toInt \"1\") (String.toInt \"1.3\") == Nothing\n\n","type":"(a -> b -> value) -> Maybe.Maybe a -> Maybe.Maybe b -> Maybe.Maybe value"},{"name":"map3","comment":" ","type":"(a -> b -> c -> value) -> Maybe.Maybe a -> Maybe.Maybe b -> Maybe.Maybe c -> Maybe.Maybe value"},{"name":"map4","comment":" ","type":"(a -> b -> c -> d -> value) -> Maybe.Maybe a -> Maybe.Maybe b -> Maybe.Maybe c -> Maybe.Maybe d -> Maybe.Maybe value"},{"name":"map5","comment":" ","type":"(a -> b -> c -> d -> e -> value) -> Maybe.Maybe a -> Maybe.Maybe b -> Maybe.Maybe c -> Maybe.Maybe d -> Maybe.Maybe e -> Maybe.Maybe value"},{"name":"mapMaybe","comment":" Apply the given function to each element of the list and collect the\nresults that are `Just _`, discarding any `Nothing`s.\nEquivalent to to [`filterMap`](#Data.List.filterMap).\n\n\n## Examples\n\nUsing mapMaybe f x is a shortcut for catMaybes $ map f x in most cases:\n\n    mapMaybe String.toInt [ \"1\", \"Foo\", \"3\" ] == [ 1, 3 ]\n\n    catMaybes (map readMaybeInt [ \"1\", \"Foo\", \"3\" ]) == [ 1, 3 ]\n\nIf we map the Just constructor, the entire list should be returned:\n\n    mapMaybe Just [ 1, 2, 3 ] == [ 1, 2, 3 ]\n\n","type":"(a -> Maybe.Maybe b) -> List.List a -> List.List b"},{"name":"maybe","comment":" Take a default value, a function, and a Maybe value. If the Maybe value\nis `Nothing`, the function returns the default value. Otherwise, it applies\nthe function to the value inside the `Just` and returns the result.\n\n\n## Examples\n\nBasic usage:\n\n    maybe False odd (Just 3) == True\n\n    maybe False odd Nothing == False\n\nRead an integer from a string. If we succeed, return twice the integer;\nthat is, apply ((\\*) 2) to it. If instead we fail to parse an integer,\nreturn 0 by default:\n\n    maybe 0 ((*) 2) (String.toInt \"5\") == 10\n\n    maybe 0 ((*) 2) (String.toInt \"\") == 0\n\nApply [`fromInt`](#String.fromInt) to a `Maybe Int`. If we have `Just n`,\nwe want to show the underlying `Int n`. But if we have `Nothing`, we return\nthe empty string instead of (for example) \"Nothing\":\n\n    maybe \"\" String.fromInt (Just 5) == \"5\"\n\n    maybe \"\" String.fromInt Nothing == \"\"\n\n","type":"b -> (a -> b) -> Maybe.Maybe a -> b"},{"name":"maybeToList","comment":" Return an empty list when given `Nothing` or a singleton list when\ngiven `Just`.\n\n\n## Examples\n\nBasic usage:\n\n    maybeToList (Just 7) == [ 7 ]\n\n    maybeToList Nothing == []\n\nOne can use maybeToList to avoid pattern matching when combined with a function that (safely) works on lists:\n\n    from Data.List import sum\n    (sum <| maybeToList (String.toInt \"3\")) == 3\n    (sum <| maybeToList (String.toInt \"\")) == 0\n\n","type":"Maybe.Maybe a -> List.List a"},{"name":"withDefault","comment":" Provide a default value, turning an optional value into a normal\nvalue. This comes in handy when paired with functions like\n[`Dict.get`](Dict#get) which gives back a `Maybe`.\n\n    withDefault 100 (Just 42) -- 42\n\n    withDefault 100 Nothing -- 100\n\n    withDefault \"unknown\" (Dict.get \"Tom\" Dict.empty) -- \"unknown\"\n\n**Note:** This can be overused! Many cases are better handled by a `case`\nexpression. And if you end up using `withDefault` a lot, it can be a good sign\nthat a [custom type][ct] will clean your code up quite a bit!\n\n[ct]: https://guide.elm-lang.org/types/custom_types.html\n\n","type":"a -> Maybe.Maybe a -> a"}],"binops":[]},{"name":"Data.Ord","comment":" Utilities working on comparable values.\n\n@docs comparing, clamp\n\n","unions":[],"aliases":[],"values":[{"name":"clamp","comment":" Cut off the upper and lower bounds.\n","type":"( comparable, comparable ) -> comparable -> comparable"},{"name":"comparing","comment":" Compare given elements by ordering function.\n","type":"(b -> comparable) -> b -> b -> Basics.Order"}],"binops":[]}]