[{"name":"List.Nonempty","comment":" A library for a non-empty list type. More obscure/specialized functions are found under Extra.\n\n\n# Definition\n\n@docs ListNonempty\n\n\n# Create\n\n@docs singleton, repeat, range, fromPair\n\n\n# Tuples\n\n@docs fromTuple, toTuple\n\n\n# Lists\n\n@docs fromList, toList\n\n\n# Transform\n\n@docs appendElem, prependElem, popFirst, popLast, map, indexedMap, foldl, foldl1, foldr, foldr1, filter, filterMap\n\n\n# Utilities\n\n@docs length, isSingleton, reverse, member, all, any, maximum, minimum, sum, product\n\n\n# Combine\n\n@docs append, concat, concatMap, map2, map3, map4, map5\n\n\n# Sort\n\n@docs sort, sortBy, sortWith\n\n\n# Deconstruct\n\n@docs head, tail, rest, last, uncons, unconsLast, take, drop, takeLast, dropLast, unzip2, unzip3\n\n","unions":[{"name":"ListNonempty","comment":" A list type that must contain at least one element\n","args":["a"],"cases":[]}],"aliases":[],"values":[{"name":"all","comment":" Same as `List.all`\n\n    fromPair 0 [ 1, 2, 3 ] |> all (\\n -> n < 2) == False\n\n    fromPair 0 [ 1, 2, 3 ] |> all (\\n -> n < 5) == True\n\n","type":"(a -> Basics.Bool) -> List.Nonempty.ListNonempty a -> Basics.Bool"},{"name":"any","comment":" Same as `List.any`\n\n    fromPair 0 [ 1, 2, 3 ] |> any (\\n -> n > 2) == True\n\n    fromPair 0 [ 1, 2, 3 ] |> any (\\n -> n > 5) == False\n\n","type":"(a -> Basics.Bool) -> List.Nonempty.ListNonempty a -> Basics.Bool"},{"name":"append","comment":" Similar to `List.append`.\n\n    append (fromPair 0 [ 1, 2 ]) (fromPair 3 [ 4, 5 ])\n        |> toList\n        == [ 0, 1, 2, 3, 4, 5 ]\n\n","type":"List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"},{"name":"appendElem","comment":" Append a value to become the new last element.\n\n    append 4 [ 1, 2, 3 ]\n        |> toList\n        == [ 1, 2, 3, 4 ]\n\n","type":"a -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"},{"name":"concat","comment":" Similar to `List.concat`\n\n    fromPair (fromPair 0 [ 1 ]) [ fromPair 2 [ 3 ] ]\n        |> concat\n        |> toList\n        == [ 0, 1, 2, 3 ]\n\n    fromPair (fromPair 0 []) []\n        |> concat\n        |> toList\n        == [ 0 ]\n\n","type":"List.Nonempty.ListNonempty (List.Nonempty.ListNonempty a) -> List.Nonempty.ListNonempty a"},{"name":"concatMap","comment":" Similar to `List.concatMap`\n\n    concatMap (\\n -> fromPair n [ n ]) (fromPair 0 [ 1, 2 ])\n        |> toList\n        == [ 0, 0, 1, 1, 2, 2 ]\n\n","type":"(a -> List.Nonempty.ListNonempty b) -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty b"},{"name":"drop","comment":" Return all elements except for the first N elements. Always includes the last element, regardless of\nthe value of N. If this behavior is undesired, use `toList` and `List.drop`\n\n    fromPair 0 [ 1, 2, 3 ] |> drop 2 |> toList == [ 2, 3 ]\n\n    fromPair 0 [ 1, 2, 3 ] |> drop 10 |> toList == [ 3 ]\n\n","type":"Basics.Int -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"},{"name":"dropLast","comment":" Return all elements except for the last N elements. Always includes the first element, regardless of\nthe value of N. If this behavior is undesired, use `toList >> List.reverse >> List.drop n >> List.reverse`\n\n    fromPair 0 [ 1, 2, 3 ] |> dropLast 2 |> toList == [ 2, 3 ]\n\n    fromPair 0 [ 1, 2, 3 ] |> dropLast 10 |> toList == [ 3 ]\n\n","type":"Basics.Int -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"},{"name":"filter","comment":" Similar to `List.filter`. Returns `List` because we cannot guarantee\nany elements will pass the test.\n\n    fromPair 1 [ 2, 3, 4 ] |> filter (\\n -> n > 2) == [ 3, 4 ]\n\n    fromPair 1 [ 2, 3, 4 ] |> filter (\\n -> n > 20) == []\n\n","type":"(a -> Basics.Bool) -> List.Nonempty.ListNonempty a -> List.List a"},{"name":"filterMap","comment":" Similar to `List.filterMap`. Also returns `List`.\n\n    fromPair \"3.5\" [ \"cat\", \"4\", \"ball\" ]\n        |> filterMap String.toFloat\n        == [ 3.5, 4 ]\n\n","type":"(a -> Maybe.Maybe b) -> List.Nonempty.ListNonempty a -> List.List b"},{"name":"foldl","comment":" Equivalent to `List.foldl`\n\n    fromPair 1 [ 2, 3 ] |> foldl (+) 0 == 6\n\n","type":"(a -> b -> b) -> b -> List.Nonempty.ListNonempty a -> b"},{"name":"foldl1","comment":" Equivalent to `List.Extra.foldl1`\n\n    fromPair 1 [ 2, 3 ] |> foldl (+) 0 == 6\n\n","type":"(a -> a -> a) -> List.Nonempty.ListNonempty a -> a"},{"name":"foldr","comment":" Equivalent to `List.foldr`\n\n    fromPair 1 [ 2, 3 ] |> foldr (+) 0 == 6\n\n","type":"(a -> b -> b) -> b -> List.Nonempty.ListNonempty a -> b"},{"name":"foldr1","comment":" Equivalent to `List.Extra.foldr1`\n\n    fromPair 1 [ 2, 3 ] |> foldr (+) 0 == 6\n\n","type":"(a -> a -> a) -> List.Nonempty.ListNonempty a -> a"},{"name":"fromList","comment":" Try to create a non-empty list from an ordinary list.\nReturns Nothing if input list is empty.\n\n    fromList [ 0, 1, 2 ] == Just (fromPair 0 [ 1, 2 ])\n\n    fromList [] == Nothing\n\n","type":"List.List a -> Maybe.Maybe (List.Nonempty.ListNonempty a)"},{"name":"fromPair","comment":" Create a non-empty list from an element and a list.\n\n    fromPair 0 [ 1, 2, 3 ] |> toList == [ 0, 1, 2, 3 ]\n\n","type":"a -> List.List a -> List.Nonempty.ListNonempty a"},{"name":"fromTuple","comment":" Create a non-empty list from a tuple of element and list\n\n    fromTuple ( 0, [ 1, 2, 3 ] ) |> toList == [ 0, 1, 2, 3 ]\n\n","type":"( a, List.List a ) -> List.Nonempty.ListNonempty a"},{"name":"head","comment":" Return the first element. Unlike `List.head`, doesn't need to return a Maybe.\n\n    fromPair 0 [ 1, 2, 3 ] |> head == 0\n\n","type":"List.Nonempty.ListNonempty a -> a"},{"name":"indexedMap","comment":" Equivalent to `List.indexedMap`\n\n    fromPair \"a\" [ \"b\", \"c\", \"d\" ]\n        |> indexedMap Tuple.pair\n        |> toList\n        == [ ( 0, \"a\" ), ( 1, \"b\" ), ( 2, \"c\" ), ( 3, \"d\" ) ]\n\n","type":"(Basics.Int -> a -> b) -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty b"},{"name":"isSingleton","comment":" Whether a non-empty list has only a single element\n\n    fromPair 0 [ 1, 2, 3 ] |> isSingleton == False\n\n    fromPair 0 [] |> isSingleton == True\n\n","type":"List.Nonempty.ListNonempty a -> Basics.Bool"},{"name":"last","comment":" Return the last element. Doesn't need to return a Maybe.\n\n    fromPair 0 [ 1, 2, 3 ] |> head == 3\n\n","type":"List.Nonempty.ListNonempty a -> a"},{"name":"length","comment":" Same as `List.length`\n\n    fromPair 0 [ 1, 2, 3 ] |> length == 4\n\n","type":"List.Nonempty.ListNonempty a -> Basics.Int"},{"name":"map","comment":" Equivalent to `List.map`\n\n    fromPair 0 [ 1, 2, 3 ]\n        |> map String.fromInt\n        |> toList\n        == [ \"0\", \"1\", \"2\", \"3\" ]\n\n","type":"(a -> b) -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty b"},{"name":"map2","comment":" Similar to `List.map2`\n\n    map2 (\\a b -> a ++ \"-\" ++ b)\n        (fromPair \"a\" [ \"b\", \"c\" ])\n        (fromPair \"1\" [ \"2\", \"3\" ])\n        |> toList\n        == [ \"a-1\", \"b-2\", \"c-3\" ]\n\n","type":"(a -> b -> result) -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty b -> List.Nonempty.ListNonempty result"},{"name":"map3","comment":" Similar to `List.map3`\n\n    map3 (\\a b c -> ( a, b, c ))\n        (fromPair 0 [ 1 ])\n        (fromPair 2 [ 3 ])\n        (fromPair 4 [ 5 ])\n        |> toList\n        == [ ( 0, 2, 4 ), ( 1, 3, 5 ) ]\n\n","type":"(a -> b -> c -> result) -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty b -> List.Nonempty.ListNonempty c -> List.Nonempty.ListNonempty result"},{"name":"map4","comment":" Similar to `List.map4`\n\n    map3 (\\a b c -> ( a, b, c ))\n        (fromPair 0 [ 1 ])\n        (fromPair 2 [ 3 ])\n        (fromPair 4 [ 5 ])\n        |> toList\n        == [ ( 0, 2, 4 ), ( 1, 3, 5 ) ]\n\n","type":"(a -> b -> c -> d -> result) -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty b -> List.Nonempty.ListNonempty c -> List.Nonempty.ListNonempty d -> List.Nonempty.ListNonempty result"},{"name":"map5","comment":" Similar to `List.map5`\n\n    map3 (\\a b c -> ( a, b, c ))\n        (fromPair 0 [ 1 ])\n        (fromPair 2 [ 3 ])\n        (fromPair 4 [ 5 ])\n        |> toList\n        == [ ( 0, 2, 4 ), ( 1, 3, 5 ) ]\n\n","type":"(a -> b -> c -> d -> e -> result) -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty b -> List.Nonempty.ListNonempty c -> List.Nonempty.ListNonempty d -> List.Nonempty.ListNonempty e -> List.Nonempty.ListNonempty result"},{"name":"maximum","comment":" Similar to `List.maximum`, but doesn't need to return a Maybe type\n\n     fromPair 0 [1, 2, 3] |> maximum == 3\n\n     fromPair 2 [] |> maximum == 2\n\n","type":"List.Nonempty.ListNonempty comparable -> comparable"},{"name":"member","comment":" Same as `List.member`\n\n    fromPair 0 [ 1, 2, 3 ] |> member 2 == True\n\n    fromPair 0 [ 1, 2, 3 ] |> member 5 == False\n\n","type":"a -> List.Nonempty.ListNonempty a -> Basics.Bool"},{"name":"minimum","comment":" Similar to `List.minimum`, but doesn't need to return a Maybe type\n\n     fromPair 0 [1, 2, 3] |> minimum == 0\n\n     fromPair 2 [] |> minimum == 2\n\n","type":"List.Nonempty.ListNonempty comparable -> comparable"},{"name":"popFirst","comment":" Pop the first element.\n\n    popFirst 4 [ 1, 2, 3 ]\n        |> toList\n        == [ 1, 2, 3, 4 ]\n\n-> Maybe (a, ListNonempty a)\n-> (a, Maybe (ListNonempty a))\n-> (a, Either (List a) (ListNonempty a))\n\n","type":"a -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"},{"name":"popLast","comment":" Pop the last element.\n\n    popLast 4 [ 1, 2, 3 ]\n        |> toList\n        == [ 1, 2, 3, 4 ]\n\n-> Maybe (a, ListNonempty a)\n-> (a, Maybe (ListNonempty a))\n-> (a, Either (List a) (ListNonempty a))\n\n","type":"a -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"},{"name":"prependElem","comment":" Prepend a value to become the new first element.\n\n    prepend 0 [ 1, 2, 3 ]\n        |> toList\n        == [ 0, 1, 2, 3 ]\n\n","type":"a -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"},{"name":"product","comment":" Equivalent to `List.product`\n\n    fromPair 1 [ 2, 3 ] |> product == 6\n\n","type":"List.Nonempty.ListNonempty number -> number"},{"name":"range","comment":" Works slightly differently from `List.range`. First provided number\nwill be the first number in the non-empty list, second provided number\nwill be the last number, and it can ascend or descend.\n\nEquivalent to `List.range a b` when `a<=b`, equal to `singleton a`\nif `a>b`\n\n    range 3 6 |> toList == [ 3, 4, 5, 6 ]\n\n    range 3 3 |> toList == [ 3 ]\n\n    range 6 3 |> toList == [ 6, 5, 4, 3 ]\n\n","type":"Basics.Int -> Basics.Int -> List.Nonempty.ListNonempty Basics.Int"},{"name":"repeat","comment":" Similar to `List.repeat`, except this is guaranteed to contain\nat least one element, regardless of the integer provided. Otherwise\na Maybe return value would be required. If this behavior is desired,\nuse `List.repeat` plus `fromList`\n\n    repeat 3 \"a\" |> toList == [ \"a\", \"a\", \"a\" ]\n\n    repeat 0 \"a\" |> toList == [ \"a\" ]\n\n","type":"Basics.Int -> a -> List.Nonempty.ListNonempty a"},{"name":"rest","comment":" Return everything except the last element. Doesn't need to return a Maybe.\n\n    fromPair 0 [ 1, 2, 3 ] |> rest == [ 0, 1, 2 ]\n\n","type":"List.Nonempty.ListNonempty a -> List.List a"},{"name":"reverse","comment":" Same as `List.reverse`.\n\n    fromPair 0 [ 1, 2, 3 ]\n        |> reverse\n        |> toList\n        == [ 3, 2, 1, 0 ]\n\n","type":"List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"},{"name":"singleton","comment":" Create a non-empty list containing just a single element\n\n    singleton 0\n\n","type":"a -> List.Nonempty.ListNonempty a"},{"name":"sort","comment":" Similar to `List.sort`\n\n    fromPair 1 [ 3, 5, 0, 2, 4 ]\n        |> sort\n        |> toList\n        == [ 0, 1, 2, 3, 4, 5 ]\n\n","type":"List.Nonempty.ListNonempty comparable -> List.Nonempty.ListNonempty comparable"},{"name":"sortBy","comment":" Similar to `List.sortBy`\n\n    fromPair { x = 1, y = 1 } [ { x = 0, y = 2 }, { x = 2, y = 0 } ]\n        |> sortBy .x\n        |> toList\n        == [ { x = 0, y = 2 }, { x = 1, y = 1 }, { x = 2, y = 0 } ]\n\n    fromPair { x = 1, y = 1 } [ { x = 0, y = 2 }, { x = 2, y = 0 } ]\n        |> sortBy .y\n        |> toList\n        == [ { x = 2, y = 0 }, { x = 1, y = 1 }, { x = 0, y = 2 } ]\n\n","type":"(a -> comparable) -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"},{"name":"sortWith","comment":" Similar to `List.sortWith`\n\n    fromPair 0 [ 1, 2, 3, 4 ]\n        |> sortWith (\\a b -> compare b a)\n        |> toList\n        == [ 4, 3, 2, 1, 0 ]\n\n","type":"(a -> a -> Basics.Order) -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"},{"name":"sum","comment":" Equivalent to `List.sum`\n\n    fromPair 1 [ 2, 3 ] |> sum == 6\n\n","type":"List.Nonempty.ListNonempty number -> number"},{"name":"tail","comment":" Return everything except the first element. Unlike `List.tail`, doesn't need to return a Maybe.\n\n    fromPair 0 [ 1, 2, 3 ] |> tail == [ 1, 2, 3 ]\n\n","type":"List.Nonempty.ListNonempty a -> List.List a"},{"name":"take","comment":" Return the first N elements. Always includes the first element, regardless of\nthe value of N. If this behavior is undesired, use `toList` and `List.take`\n\n    fromPair 0 [ 1, 2, 3 ] |> take 2 |> toList == [ 0, 1 ]\n\n    fromPair 0 [ 1, 2, 3 ] |> take 0 |> toList == [ 0 ]\n\n","type":"Basics.Int -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"},{"name":"takeLast","comment":" Return the last N elements. Always includes the last element, regardless of\nthe value of N. If this behavior is undesired, use `toList >> List.reverse >> List.take n >> List.reverse`\n\n    fromPair 0 [ 1, 2, 3 ] |> takeLast 2 |> toList == [ 2, 3 ]\n\n    fromPair 0 [ 1, 2, 3 ] |> takeLast 0 |> toList == [ 3 ]\n\n","type":"Basics.Int -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"},{"name":"toList","comment":" Convert to a list\n\n    fromPair 0 [ 1, 2, 3 ] |> toList == [ 0, 1, 2, 3 ]\n\n","type":"List.Nonempty.ListNonempty a -> List.List a"},{"name":"toTuple","comment":" Deconstruct a non-empty list into a tuple of element and list\n\n    fromTuple ( 0, [ 1, 2, 3 ] )\n        |> toTuple\n        == ( 0, [ 1, 2, 3 ] )\n\n","type":"List.Nonempty.ListNonempty a -> ( a, List.List a )"},{"name":"uncons","comment":" Equivalent to `(\\elems -> (head elems, tail elems))`\n\n    fromPair 0 [ 1, 2, 3 ] |> uncons == ( 0, [ 1, 2, 3 ] )\n\n","type":"List.Nonempty.ListNonempty a -> ( a, List.List a )"},{"name":"unconsLast","comment":" Equivalent to `(\\elems -> (rest elems, last elems))`\n\n    fromPair 0 [ 1, 2, 3 ] |> unconsLast == ( [ 0, 1, 2 ], 3 )\n\n","type":"List.Nonempty.ListNonempty a -> ( List.List a, a )"},{"name":"unzip2","comment":" Similar to `List.unzip`.\n\n    fromPair ( \"a\", 1 ) [ ( \"b\", 2 ), ( \"c\", 3 ) ]\n        |> unzip2\n        == ( fromPair \"a\" [ \"b\", \"c\" ]\n           , fromPair 1 [ 2, 3 ]\n           )\n\n","type":"List.Nonempty.ListNonempty ( a, b ) -> ( List.Nonempty.ListNonempty a, List.Nonempty.ListNonempty b )"},{"name":"unzip3","comment":" Similar to `unzip2`, but with 3-tuples.\n\n    fromPair ( 1, 2, 3 ) [ ( 4, 5, 6 ), ( 7, 8, 9 ) ]\n        |> unzip3\n        == ( fromPair 1 [ 4, 7 ]\n           , fromPair 2 [ 5, 8 ]\n           , fromPair 3 [ 6, 9 ]\n           )\n\n","type":"List.Nonempty.ListNonempty ( a, b, c ) -> ( List.Nonempty.ListNonempty a, List.Nonempty.ListNonempty b, List.Nonempty.ListNonempty c )"}],"binops":[]},{"name":"List.Nonempty.Extra","comment":" Various helper functions, perhaps too specialized for frequent use\n\n\n# Basics\n\n@docs unique, uniqueBy, setIf, setAt, setIfIndex, updateIf, updateAt, updateIfIndex, swapAt, maximumBy, maximumWith, minimumBy, minimumWith\n\n\n# List transformations\n\n@docs intersperse, transpose, subsequences, permutations\n\n\n# Folds\n\n@docs indexedFoldl, indexedFoldr\n\n\n# Building lists\n\n@docs scanl, scanlList, scanl1, scanr, scanrList, scanr1, mapAccuml, mapAccumr, iterate, initialize, appendList, prependList\n\n\n# Sublists\n\n@docs splitAtTail, splitAtRest, group, groupList, groupWhile, groupWhileList, prefixes, suffixes, select, selectSplit, gatherEquals, gatherEqualsBy, gatherEqualsByList, gatherEqualsList, gatherWith, gatherWithList, frequencies, partition\n\n\n# Searching\n\n@docs notMember\n\n\n# Lift\n\n@docs lift2, lift3, lift4\n\n\n# Split to groups\n\n@docs groupsOf, groupsOfWithStep, groupsOfVarying, greedyGroupsOf, greedyGroupsOfWithStep\n\n","unions":[],"aliases":[],"values":[{"name":"appendList","comment":" Similar to append, except taking an ordinary list as second argument.\n\n    appendList (fromPair 0 [ 1, 2 ]) [ 3, 4, 5 ]\n        |> toList\n        == [ 0, 1, 2, 3, 4, 5 ]\n\n","type":"List.Nonempty.ListNonempty a -> List.List a -> List.Nonempty.ListNonempty a"},{"name":"frequencies","comment":" Similar to `List.Extra.frequencies`.\n","type":"List.Nonempty.ListNonempty comparable -> List.Nonempty.ListNonempty ( comparable, Basics.Int )"},{"name":"gatherEquals","comment":" Similar to `List.Extra.gatherEquals`.\n","type":"List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty (List.Nonempty.ListNonempty a)"},{"name":"gatherEqualsBy","comment":" Similar to `List.Extra.gatherEqualsBy`.\n","type":"(a -> b) -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty (List.Nonempty.ListNonempty a)"},{"name":"gatherEqualsByList","comment":" Similar to `gatherEqualsBy`, except operating on `List`.\n","type":"(a -> b) -> List.List a -> List.List (List.Nonempty.ListNonempty a)"},{"name":"gatherEqualsList","comment":" Similar to `gatherEquals` except operating on `List`.\n","type":"List.List a -> List.List (List.Nonempty.ListNonempty a)"},{"name":"gatherWith","comment":" Similar to `List.Extra.gatherWith`.\n","type":"(a -> a -> Basics.Bool) -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty (List.Nonempty.ListNonempty a)"},{"name":"gatherWithList","comment":" Similar to `gatherWith`, except operating on `List`.\n","type":"(a -> a -> Basics.Bool) -> List.List a -> List.List (List.Nonempty.ListNonempty a)"},{"name":"greedyGroupsOf","comment":" Similar to `List.Extra.greedyGroupsOf`.\n","type":"Basics.Int -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty (List.Nonempty.ListNonempty a)"},{"name":"greedyGroupsOfWithStep","comment":" Similar to `List.Extra.greedyGroupsOfWithStep`.\n","type":"Basics.Int -> Basics.Int -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty (List.Nonempty.ListNonempty a)"},{"name":"group","comment":" Similar to `List.Extra.group`.\n","type":"List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty (List.Nonempty.ListNonempty a)"},{"name":"groupList","comment":" Similar to `group`, but works on `List`.\n","type":"List.List a -> List.List (List.Nonempty.ListNonempty a)"},{"name":"groupWhile","comment":" Similar to `List.Extra.groupWhile`.\n","type":"(a -> a -> Basics.Bool) -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty (List.Nonempty.ListNonempty a)"},{"name":"groupWhileList","comment":" Similar to `groupWhile`, but works on `List`.\n","type":"(a -> a -> Basics.Bool) -> List.List a -> List.List (List.Nonempty.ListNonempty a)"},{"name":"groupsOf","comment":" Similar to `List.Extra.groupsOf`.\n","type":"Basics.Int -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty (List.Nonempty.ListNonempty a)"},{"name":"groupsOfVarying","comment":" Similar to `List.Extra.groupsOfVarying`.\n","type":"List.Nonempty.ListNonempty Basics.Int -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty (List.Nonempty.ListNonempty a)"},{"name":"groupsOfWithStep","comment":" Similar to `List.Extra.groupsOfWithStep`.\n","type":"Basics.Int -> Basics.Int -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty (List.Nonempty.ListNonempty a)"},{"name":"indexedFoldl","comment":" Similar to `List.Extra.indexedFoldl`\n","type":"(Basics.Int -> a -> b -> b) -> b -> List.Nonempty.ListNonempty a -> b"},{"name":"indexedFoldr","comment":" Similar to `List.Extra.indexedFoldr`\n","type":"(Basics.Int -> a -> b -> b) -> b -> List.Nonempty.ListNonempty a -> b"},{"name":"initialize","comment":" Similar to `List.Extra.initialize`.\n","type":"Basics.Int -> (Basics.Int -> a) -> List.Nonempty.ListNonempty a"},{"name":"intersperse","comment":" Similar to `List.intersperse`\n\n    intersperse \".\" (fromPair \"127\" [ \"0\", \"0\", \"1\" ])\n        |> toList\n        == [ \"127\", \".\", \"0\", \".\", \"0\", \".\", \"1\" ]\n\n","type":"a -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"},{"name":"iterate","comment":" Similar to `List.Extra.iterate`\n","type":"(a -> Maybe.Maybe a) -> a -> List.Nonempty.ListNonempty a"},{"name":"lift2","comment":" Similar to `List.Extra.lift2`.\n","type":"(a -> b -> c) -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty b -> List.Nonempty.ListNonempty c"},{"name":"lift3","comment":" Similar to `List.Extra.lift3`.\n","type":"(a -> b -> c -> d) -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty b -> List.Nonempty.ListNonempty c -> List.Nonempty.ListNonempty d"},{"name":"lift4","comment":" Similar to `List.Extra.lift4`.\n","type":"(a -> b -> c -> d -> e) -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty b -> List.Nonempty.ListNonempty c -> List.Nonempty.ListNonempty d -> List.Nonempty.ListNonempty e"},{"name":"mapAccuml","comment":" Similar to `List.Extra.mapAccuml`\n","type":"(a -> b -> ( a, c )) -> a -> List.Nonempty.ListNonempty b -> ( a, List.Nonempty.ListNonempty c )"},{"name":"mapAccumr","comment":" Similar to `List.Extra.mapAccumr`\n","type":"(a -> b -> ( a, c )) -> a -> List.Nonempty.ListNonempty b -> ( a, List.Nonempty.ListNonempty c )"},{"name":"maximumBy","comment":" Similar to `List.Extra.maximumBy`\n","type":"(a -> comparable) -> List.Nonempty.ListNonempty a -> a"},{"name":"maximumWith","comment":" Similar to `List.Extra.maximumWith`\n","type":"(a -> a -> Basics.Order) -> List.Nonempty.ListNonempty a -> a"},{"name":"minimumBy","comment":" Similar to `List.Extra.minimumBy`\n","type":"(a -> comparable) -> List.Nonempty.ListNonempty a -> a"},{"name":"minimumWith","comment":" Similar to `List.Extra.minimumWith`\n","type":"(a -> a -> Basics.Order) -> List.Nonempty.ListNonempty a -> a"},{"name":"notMember","comment":" Similar to `List.Extra.notMember`.\n","type":"a -> List.Nonempty.ListNonempty a -> Basics.Bool"},{"name":"partition","comment":" Equivalent to `List.partition`. We can't have any (simple) guarantees about\nthe lengths of the two returned lists.\n\n    fromPair 2 [ 5, 1, 4 ]\n        |> partition (\\n -> n > 2)\n        == ( [ 5, 4 ], [ 2, 1 ] )\n\n","type":"(a -> Basics.Bool) -> List.Nonempty.ListNonempty a -> ( List.List a, List.List a )"},{"name":"permutations","comment":" Similar to `List.Extra.permutations`\n","type":"List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty (List.Nonempty.ListNonempty a)"},{"name":"prefixes","comment":" Similar to `List.Extra.inits`.\n","type":"List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty (List.Nonempty.ListNonempty a)"},{"name":"prependList","comment":" Similar to append, except taking an ordinary list as first argument.\n\n    appendList (fromPair 0 [ 1, 2 ]) [ 3, 4, 5 ]\n        |> toList\n        == [ 0, 1, 2, 3, 4, 5 ]\n\n","type":"List.List a -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"},{"name":"scanl","comment":" Similar to `List.Extra.scanl`\n","type":"(a -> b -> b) -> b -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty b"},{"name":"scanl1","comment":" Similar to `List.Extra.scanl1` except doesn't need to return a `Maybe`. The function is `(a -> a -> a)` though, instead of `(a -> b -> b)`.\n","type":"(a -> a -> a) -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"},{"name":"scanlList","comment":" Similar to `scanl`, except takes a `List` as input. Output is still guaranteed to be non-empty.\n","type":"(a -> b -> b) -> b -> List.List a -> List.Nonempty.ListNonempty b"},{"name":"scanr","comment":" Similar to `List.Extra.scanr`\n","type":"(a -> b -> b) -> b -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty b"},{"name":"scanr1","comment":" Similar to `List.Extra.scanr1` except doesn't need to return a `Maybe`. The function is `(a -> a -> a)` though, instead of `(a -> b -> b)`.\n","type":"(a -> a -> a) -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"},{"name":"scanrList","comment":" Similar to `scanr`, except takes a `List` as input. Output is still guaranteed to be non-empty.\n","type":"(a -> b -> b) -> b -> List.List a -> List.Nonempty.ListNonempty b"},{"name":"select","comment":" Similar to `List.Extra.select`. Output type was chosen because the output of this function is likely intended to be used as separate pieces. If output type of `ListNonempty (ListNonempty a)` is desired, use `select >> map fromTuple`.\n","type":"List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty ( a, List.List a )"},{"name":"selectSplit","comment":" Similar to `List.Extra.selectSplit`.\n","type":"List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty ( List.List a, a, List.List a )"},{"name":"setAt","comment":" Similar to `List.Extra.setAt`\n","type":"Basics.Int -> a -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"},{"name":"setIf","comment":" Similar to `List.Extra.setIf`\n","type":"(a -> Basics.Bool) -> a -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"},{"name":"setIfIndex","comment":" `List.Extra.setIf` meets `List.Extra.updateIfIndex`\n","type":"(Basics.Int -> Basics.Bool) -> a -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"},{"name":"splitAtRest","comment":" Similar to `List.Extra.splitAt`. Compare with `splitAtTail`.\n","type":"Basics.Int -> List.Nonempty.ListNonempty a -> ( List.List a, List.Nonempty.ListNonempty a )"},{"name":"splitAtTail","comment":" Similar to `List.Extra.splitAt`. Compare with `splitAtRest`.\n","type":"Basics.Int -> List.Nonempty.ListNonempty a -> ( List.Nonempty.ListNonempty a, List.List a )"},{"name":"subsequences","comment":" Similar to `List.Extra.subsequences`\n","type":"List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty (List.Nonempty.ListNonempty a)"},{"name":"suffixes","comment":" Similar to `List.Extra.tails`.\n","type":"List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty (List.Nonempty.ListNonempty a)"},{"name":"swapAt","comment":" Similar to `List.Extra.swapAt`\n","type":"Basics.Int -> Basics.Int -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"},{"name":"transpose","comment":" Similar to `List.Extra.transpose`\n","type":"List.Nonempty.ListNonempty (List.Nonempty.ListNonempty a) -> List.Nonempty.ListNonempty (List.Nonempty.ListNonempty a)"},{"name":"unique","comment":" Similar to `List.Extra.unique`\n\n    fromPair 0 [ 1, 0, 2 ] |> unique == fromPair 0 [ 1, 2 ]\n\n","type":"List.Nonempty.ListNonempty comparable -> List.Nonempty.ListNonempty comparable"},{"name":"uniqueBy","comment":" Similar to `List.Extra.uniqueBy`\n","type":"(a -> comparable) -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"},{"name":"updateAt","comment":" Similar to `List.Extra.updateAt`\n","type":"Basics.Int -> (a -> a) -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"},{"name":"updateIf","comment":" Similar to `List.Extra.updateIf`\n","type":"(a -> Basics.Bool) -> (a -> a) -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"},{"name":"updateIfIndex","comment":" Similar to `List.Extra.updateIfIndex`\n","type":"(Basics.Int -> Basics.Bool) -> (a -> a) -> List.Nonempty.ListNonempty a -> List.Nonempty.ListNonempty a"}],"binops":[]}]