[{"name":"Json.Decode.NotEmpty","comment":"\n\nFunctions for encoding not empty collections into JSON values\n\n@docs list, array, dict, set, string\n","unions":[],"aliases":[],"values":[{"name":"array","comment":" Decode a JSON array into a [`NotEmpty.Array`](NotEmpty.Array#Array)","type":"Json.Decode.Decoder item -> Json.Decode.Decoder (NotEmpty.Array item)"},{"name":"dict","comment":" Decode a JSON object into a [`NotEmpty.Dict`](NotEmpty.Dict#Dict)\n\n    import Json.Decode as D\n    import Json.Decode.NotEmpty exposing(dict)\n\n    D.decodeString ( dict D.int ) \"{ \\\"alice\\\": 42, \\\"bob\\\": 99 }\" == Ok ( NotEmpty.Dict.fromListWithPair \"alice\" 42 [ ( \"bob\", 99 ) ] )\n    \n    D.decodeString ( dict D.int ) \"{}\" == Err ...\n","type":"Json.Decode.Decoder value -> Json.Decode.Decoder (NotEmpty.Dict String.String value)"},{"name":"list","comment":" Decode a JSON array into a [`NotEmpty.List`](NotEmpty.List#List)\n\n    decodeString ( list int ) \"[ 1, 2, 3 ]\"   == Ok ( NotEmpty.List.withHead 1 [ 2, 3 ] )\n    decodeString ( list bool ) \"[]\"           == Err ...\n","type":"Json.Decode.Decoder item -> Json.Decode.Decoder (NotEmpty.List item)"},{"name":"set","comment":" Decode a JSON array into a [`NotEmpty.Set.Set`](NotEmpty.Set#Set) ","type":"Json.Decode.Decoder comparable -> Json.Decode.Decoder (NotEmpty.Set comparable)"},{"name":"string","comment":" Decode a JSON string into a [`NotEmpty.String.String`](NotEmpty.String#String) ","type":"Json.Decode.Decoder NotEmpty.String"}],"binops":[]},{"name":"Json.Encode.NotEmpty","comment":"\n\nFunctions for encoding not empty collections into JSON values\n\n@docs list, array, set, dict, string\n","unions":[],"aliases":[],"values":[{"name":"array","comment":" Turn a [`NotEmpty.Array`](NotEmpty.Array#Array) into a JSON array. ","type":"(item -> Json.Encode.Value) -> NotEmpty.Array item -> Json.Encode.Value"},{"name":"dict","comment":" Turn a [`NotEmpty.Dict`](NotEmpty.Dict#Dict) into a JSON object. ","type":"(comparable -> String.String) -> (value -> Json.Encode.Value) -> NotEmpty.Dict comparable value -> Json.Encode.Value"},{"name":"list","comment":" Turn a [`NotEmpty.List`](NotEmpty.List#List) into a JSON array. ","type":"(item -> Json.Encode.Value) -> NotEmpty.List item -> Json.Encode.Value"},{"name":"set","comment":" Turn a [`NotEmpty.Set.Set`](NotEmpty.Set#Set) into a JSON array. ","type":"(comparable -> Json.Encode.Value) -> NotEmpty.Set comparable -> Json.Encode.Value"},{"name":"string","comment":" Turn a [`NotEmpty.String`](NotEmpty.String#String) into a JSON array. ","type":"NotEmpty.String -> Json.Encode.Value"}],"binops":[]},{"name":"NotEmpty","comment":"\nModule with aliases for the different collection types so you can type\n\n    foo : NotEmpty.List Int\ninstead of\n\n    foo : NotEmpty.List.List Int\n\n@docs List, Array, Dict, Set, String\n\n","unions":[],"aliases":[{"name":"Array","comment":" Alias for [`NotEmpty.Array.Array`](NotEmpty.Array#Array) ","args":["a"],"type":"NotEmpty.Array.Array a"},{"name":"Dict","comment":" Alias for [`NotEmpty.Dict.Dict`](NotEmpty.Dict#Dict) ","args":["key","value"],"type":"NotEmpty.Dict.Dict key value"},{"name":"List","comment":" Alias for [`NotEmpty.List.List`](NotEmpty.List#List) ","args":["a"],"type":"NotEmpty.List.List a"},{"name":"Set","comment":" Alias for [`NotEmpty.Set.Set`](NotEmpty.Set#Set) ","args":["a"],"type":"NotEmpty.Set.Set a"},{"name":"String","comment":" Alias for [`NotEmpty.String.String`](NotEmpty.String#String) ","args":[],"type":"NotEmpty.String.String"}],"values":[],"binops":[]},{"name":"NotEmpty.Array","comment":"\n@docs Array\n\n# Create\n\n@docs singleton, initialize, repeat, withHead, fromList, fromListWithHead\n\n# Transforming from and to regular arrays\n\n@docs fromArray, toArray\n\n# New functions\n\n@docs head, last, tail, hasTail, appendArray, prependArray\n\n# Modified functions\n\n@docs filter\n\n# Unchanged functions\n\n@docs get, set, push, append, length\n\n@docs map, indexedMap, foldl, foldr\n\n@docs toList, toIndexedList\n\n","unions":[],"aliases":[{"name":"Array","comment":" Not empty version of `Array` ","args":["item"],"type":"( item, Array.Array item )"}],"values":[{"name":"append","comment":" Same as `Array.append` ","type":"NotEmpty.Array.Array a -> NotEmpty.Array.Array a -> NotEmpty.Array.Array a"},{"name":"appendArray","comment":" Append a regular array to a not empty array\n\n    appendArray ( repeat 2 42 ) ( Array.repeat 3 81 ) == fromListWithHead 42 [ 42, 81, 81, 81 ]\n","type":"NotEmpty.Array.Array a -> Array.Array a -> NotEmpty.Array.Array a"},{"name":"filter","comment":" Same as `Array.filter` but will return Nothing if no elements satisfy the test\n\n    filter isEven ( fromListWithHead 1 [ 2, 3, 4, 5, 6 ] ) == Just ( fromListWithHead 2 [ 4, 6 ] )\n    filter isEven ( fromListWithHead 1 [ 3, 5 ] ) == Nothing\n\n","type":"(a -> Basics.Bool) -> NotEmpty.Array.Array a -> Maybe.Maybe (NotEmpty.Array.Array a)"},{"name":"foldl","comment":" Same as `Array.foldl` ","type":"(a -> b -> b) -> b -> NotEmpty.Array.Array a -> b"},{"name":"foldr","comment":" Same as `Array.foldr` ","type":"(a -> b -> b) -> b -> NotEmpty.Array.Array a -> b"},{"name":"fromArray","comment":" Convert a regular array into a not empty array, or Nothing if the array is empty\n\n    fromArray ( Array.fromList [] ) == Nothing\n    fromArray ( Array.fromList [ 1, 2, 3 ] ) == Just ( fromListWithHead 1 [ 2, 3 ] )\n","type":"Array.Array a -> Maybe.Maybe (NotEmpty.Array.Array a)"},{"name":"fromList","comment":" Same as `Array.fromList` except using a [`NotEmpty.List`](NotEmpty.List#List) ","type":"NotEmpty.List.List a -> NotEmpty.Array.Array a"},{"name":"fromListWithHead","comment":" Same as [`withHead`](NotEmpty.Array#withHead) but with a list instead of a array ","type":"a -> List.List a -> NotEmpty.Array.Array a"},{"name":"get","comment":" Same as `Array.get` ","type":"Basics.Int -> NotEmpty.Array.Array a -> Maybe.Maybe a"},{"name":"hasTail","comment":" Returns wether the array has a tail with elements\n\n    hasTail ( fromListWithHead 1 [ 2, 3 ] ) == True\n    hasTail ( singleton 1 ) == False\n    hasTail ( fromListWithHead 1 [] ) == False\n","type":"NotEmpty.Array.Array a -> Basics.Bool"},{"name":"head","comment":" Extract the first element from a not empty array.\n\n    head ( fromListWithHead 1 [ 2, 3 ] ) == 1\n    head ( singleton 1 ) == 1\n","type":"NotEmpty.Array.Array a -> a"},{"name":"indexedMap","comment":" Same as `Array.indexedMap` ","type":"(Basics.Int -> a -> b) -> NotEmpty.Array.Array a -> NotEmpty.Array.Array b"},{"name":"initialize","comment":" Same as `Array.initialize`.\n\nWill always include at least 1 value ( initialized with index 0 ).\n\n    initialize 4 identity    == fromListWithHead 0 [ 1, 2, 3 ]\n    initialize 4 ( \\n -> n * n ) == fromListWithHead 0 [ 1, 4, 9 ]\n    initialize 4 ( always 0 ) == fromListWithHead 0 [ 0, 0, 0 ]\n    initialize 0 ( \\n -> n + 4 ) == singleton 4\n\n","type":"Basics.Int -> (Basics.Int -> a) -> NotEmpty.Array.Array a"},{"name":"last","comment":" Extract the last element from a not empty array.\n\n    last ( fromListWithHead 1 [ 2, 3 ] ) == 3\n    last ( singleton 1 ) == 1\n","type":"NotEmpty.Array.Array a -> a"},{"name":"length","comment":" Same as `Array.length` ","type":"NotEmpty.Array.Array a -> Basics.Int"},{"name":"map","comment":" Same as `Array.map` ","type":"(a -> b) -> NotEmpty.Array.Array a -> NotEmpty.Array.Array b"},{"name":"prependArray","comment":" Prepend a regular array to a not empty array\n\n    prependArray ( Array.repeat 2 42 ) ( repeat 3 81 ) == fromListWithHead 42 [ 42, 81, 81, 81 ]\n","type":"Array.Array a -> NotEmpty.Array.Array a -> NotEmpty.Array.Array a"},{"name":"push","comment":" Same as `Array.push` ","type":"a -> NotEmpty.Array.Array a -> NotEmpty.Array.Array a"},{"name":"repeat","comment":" Same as `Array.repeat`.\n\nWill always include at least 1 value.\n\n    repeat 4 \"Value\" == fromListWithHead \"Value\" [ \"Value\", \"Value\", \"Value\" ]\n    repeat 0 \"Test\" == singleton \"Test\"\n\n","type":"Basics.Int -> a -> NotEmpty.Array.Array a"},{"name":"set","comment":" Same as `Array.set` ","type":"Basics.Int -> a -> NotEmpty.Array.Array a -> NotEmpty.Array.Array a"},{"name":"singleton","comment":" A not empty array containing only the given value.\n\n    toList ( singleton \"a\" ) == [ \"a\" ]\n","type":"a -> NotEmpty.Array.Array a"},{"name":"tail","comment":" Returns the elements after the first element as a regular array\n\n    tail ( fromListWithHead 1 [ 2, 3 ] ) == Array.fromList [ 2, 3 ]\n    tail ( singleton 1 ) == Array.fromList []\n","type":"NotEmpty.Array.Array a -> Array.Array a"},{"name":"toArray","comment":" Convert a not empty array into a regular array\n\n  toArray ( fromListWithHead 1 [ 2, 3 ] ) == Array.fromList [ 1, 2, 3 ]\n  toArray ( singleton 1 ) == Array.fromList [ 1 ]\n","type":"NotEmpty.Array.Array a -> Array.Array a"},{"name":"toIndexedList","comment":" Same as `Array.toIndexedList` ","type":"NotEmpty.Array.Array a -> NotEmpty.List.List ( Basics.Int, a )"},{"name":"toList","comment":" Same as `Array.toList` ","type":"NotEmpty.Array.Array a -> NotEmpty.List.List a"},{"name":"withHead","comment":" A not empty array list with the given head and tail\n\n    array = withHead 5 ( Array.fromList [ 4, 3 ] )\n    toArray array == Array.fromList [ 5, 4, 3 ]\n    head array == 5\n    tail array == Array.fromList [ 4, 3 ]\n","type":"a -> Array.Array a -> NotEmpty.Array.Array a"}],"binops":[]},{"name":"NotEmpty.Dict","comment":"\n@docs Dict\n\n# Create\n\n@docs singleton, withPair, fromList, fromListWithPair\n\n# Transforming from and to regular dictionaries\n\n@docs fromDict, toDict\n\n# New functions\n\n@docs head, last, tail, hasTail\n\n# Modified functions\n\n@docs remove, filter, diff, intersect\n\n# Unchanged functions\n\n@docs get, member, insert, size, toList\n\n@docs map, foldl, foldr\n\n@docs union, merge\n\n","unions":[],"aliases":[{"name":"Dict","comment":" Not empty version of `Dict` ","args":["key","value"],"type":"( ( key, value ), Dict.Dict key value )"}],"values":[{"name":"diff","comment":" Same as `Dict.diff` but will return Nothing if the resulting dictionary is empty\n\n    diff ( fromListWithPair 1 1 [ ( 2, 2 ), ( 3, 3 ) ] ) ( singleton 1 \"one\" ) == Just ( fromListWithPair 2 2 [ ( 3, 3 ) ] )\n    diff ( singleton 1 1 ) ( singleton 1 \"one\" ) == Nothing\n    diff ( singleton 2 2 ) ( singleton 1 \"one\" ) == Just ( singleton 2 2 )\n","type":"NotEmpty.Dict.Dict comparable value -> NotEmpty.Dict.Dict comparable a -> Maybe.Maybe (NotEmpty.Dict.Dict comparable value)"},{"name":"filter","comment":" Same as `Dict.filter` but will return Nothing if no pairs satisfy the test\n\n    filter isKeyEven ( fromListWithPair 1 1 [ ( 2, 2 ), ( 3, 3 ) ] ) == Just ( fromListWithPair 2 2 [] )\n    filter isKeyEven ( singleton 1 1 ) == Nothing\n","type":"(comparable -> value -> Basics.Bool) -> NotEmpty.Dict.Dict comparable value -> Maybe.Maybe (NotEmpty.Dict.Dict comparable value)"},{"name":"foldl","comment":" Same as `Dict.foldl` ","type":"(key -> value -> b -> b) -> b -> NotEmpty.Dict.Dict key value -> b"},{"name":"foldr","comment":" Same as `Dict.foldr` ","type":"(key -> value -> b -> b) -> b -> NotEmpty.Dict.Dict key value -> b"},{"name":"fromDict","comment":" Convert a regular dict into a not empty dict, or Nothing if the dict is empty\n\n    fromDict ( Dict.fromList [] ) == Nothing\n    fromDict ( Dict.fromList [ ( 1, \"one\" ), ( 2, \"two\" ), ( 3, \"three\" ) ] ) == Just ( fromListWithPair 1 \"one\" [ ( 2, \"two\" ), ( 3, \"three\" ) ] )\n","type":"Dict.Dict comparable value -> Maybe.Maybe (NotEmpty.Dict.Dict comparable value)"},{"name":"fromList","comment":" Same as `Dict.fromList` except using a [`NotEmpty.List`](NotEmpty.List#List) ","type":"NotEmpty.List.List ( comparable, value ) -> NotEmpty.Dict.Dict comparable value"},{"name":"fromListWithPair","comment":" Same as [`withPair`](NotEmpty.Dict#withPair) but with a list or pairs instead of a dict ","type":"comparable -> value -> List.List ( comparable, value ) -> NotEmpty.Dict.Dict comparable value"},{"name":"get","comment":" Same as `Dict.get` ","type":"comparable -> NotEmpty.Dict.Dict comparable value -> Maybe.Maybe value"},{"name":"hasTail","comment":" Returns wether the dictionary has a tail with elements\n\n    hasTail ( fromListWithPair 1 \"one\" [ ( 2, \"two\" ), ( 3, \"three\" ) ] ) == True\n    hasTail ( singleton 1 \"one\" ) == False\n    hasTail ( fromListWithHead 1 \"one\" [] ) == False\n","type":"NotEmpty.Dict.Dict key value -> Basics.Bool"},{"name":"head","comment":" Extract the first pair from a not empty dictionary.\n\n    head ( fromListWithPair 1 \"one\" [ ( 2, \"two\" ), ( 3, \"three\" ) ] ) == ( 1, \"one\" )\n    head ( singleton 1 \"one\" ) == ( 1, \"one\" )\n","type":"NotEmpty.Dict.Dict key value -> ( key, value )"},{"name":"insert","comment":" Same as `Dict.insert` ","type":"comparable -> value -> NotEmpty.Dict.Dict comparable value -> NotEmpty.Dict.Dict comparable value"},{"name":"intersect","comment":" Same as `Dict.intersect` but will return Nothing if the resulting dictionary is empty\n\n    intersect ( fromListWithPair 1 1 [ ( 2, 2 ), ( 3, 3 ) ] ) ( singleton 1 \"one\" ) == Just ( fromListWithPair 1 1 [] )\n    intersect ( singleton 1 1 ) ( singleton 1 \"one\" ) == Just ( singleton 1 1 )\n    intersect ( singleton 2 2 ) ( singleton 1 \"one\" ) == Nothing\n","type":"NotEmpty.Dict.Dict comparable value -> NotEmpty.Dict.Dict comparable a -> Maybe.Maybe (NotEmpty.Dict.Dict comparable value)"},{"name":"last","comment":" Extract the last pair from a not empty dictionary.\n\n    last ( fromListWithPair 1 \"one\" [ ( 2, \"two\" ), ( 3, \"three\" ) ] ) == ( 3, \"three\" )\n    last ( singleton 1 \"one\" ) == ( 1, \"one\" )\n","type":"NotEmpty.Dict.Dict key value -> ( key, value )"},{"name":"map","comment":" Same as `Dict.map` ","type":"(key -> a -> b) -> NotEmpty.Dict.Dict key a -> NotEmpty.Dict.Dict key b"},{"name":"member","comment":" Same as `Dict.member` ","type":"comparable -> NotEmpty.Dict.Dict comparable value -> Basics.Bool"},{"name":"merge","comment":" Same as `Dict.merge` ","type":"(comparable -> a -> result -> result) -> (comparable -> a -> b -> result -> result) -> (comparable -> b -> result -> result) -> NotEmpty.Dict.Dict comparable a -> NotEmpty.Dict.Dict comparable b -> result -> result"},{"name":"remove","comment":" Same as `Dict.remove` but will return Nothing if the last value is removed\n\n    remove 1 ( fromListWithPair 1 \"one\" [ ( 2, \"two\" ), ( 3, \"three\" ) ] ) == Just ( fromListWithPair 2 \"two\" [ ( 3, \"three\" ) ] )\n    remove 1 ( singleton 1 \"one\" ) == Nothing\n    remove 2 ( singleton 1 \"one\" ) == Just ( singleton 1 \"one\" )\n","type":"comparable -> NotEmpty.Dict.Dict comparable value -> Maybe.Maybe (NotEmpty.Dict.Dict comparable value)"},{"name":"singleton","comment":" Create a non empty dictionary with one key-value pair. ","type":"key -> value -> NotEmpty.Dict.Dict key value"},{"name":"size","comment":" Same as `Dict.size` ","type":"NotEmpty.Dict.Dict key value -> Basics.Int"},{"name":"tail","comment":" Returns the elements after the first pair as a regular dictionary\n\n    tail ( fromListWithPair 1 \"one\" [ ( 2, \"two\" ), ( 3, \"three\" ) ] ) == Dict.fromList [ ( 2, \"two\" ), ( 3, \"three\" ) ]\n    tail ( singleton 1 \"one\" ) == Dict.fromList []\n","type":"NotEmpty.Dict.Dict key value -> Dict.Dict key value"},{"name":"toDict","comment":" Convert a not empty dict into a regular dict\n\n    toDict ( fromListWithPair 1 \"one\" [ ( 2, \"two\" ), ( 3, \"three\" ) ] ) == Dict.fromList [ ( 1, \"one\" ), ( 2, \"two\" ), ( 3, \"three\" ) ]\n    toDict ( singleton 1 \"one\" ) == Dict.fromList [ ( 1, \"one\" ) ]\n","type":"NotEmpty.Dict.Dict comparable value -> Dict.Dict comparable value"},{"name":"toList","comment":" Same as `Dict.toList` ","type":"NotEmpty.Dict.Dict key value -> NotEmpty.List.List ( key, value )"},{"name":"union","comment":" Same as `Dict.union` ","type":"NotEmpty.Dict.Dict comparable value -> NotEmpty.Dict.Dict comparable value -> NotEmpty.Dict.Dict comparable value"},{"name":"withPair","comment":" Create a non empty dictionary from a regular dictionary and a given pair.\n\nIn contrast to [`fromDict`](NotEmpty.Dict#fromDict) this will always return a value since there is always at least 1 pair.\n\n    dict = withPair 5 \"Five\" ( Dict.fromList [ ( 4, \"Four\" ), ( 3, \"Three\" ) ] )\n    toDict dict == Dict.fromList [ ( 3, \"Three\" ), ( 4, \"Four\" ), ( 5, \"Five\" ) ]\n","type":"comparable -> value -> Dict.Dict comparable value -> NotEmpty.Dict.Dict comparable value"}],"binops":[]},{"name":"NotEmpty.List","comment":"\n\n@docs List\n\n# Create\n\n@docs singleton, repeat, range, withHead, cons\n\n# Transforming from and to regular lists\n\n@docs fromList, toList\n\n# New functions\n\n@docs unCons, last, hasTail, appendList, appendToList\n\n# Modified functions\n\n@docs head, tail, maximum, minimum\n\n@docs take, drop\n\n@docs filter, filterMap, partition, PartitionResult\n\n# Unchanged functions\n\n@docs length, reverse, member, all, any, sum, product\n\n@docs map, indexedMap, foldl, foldr, foldl1, foldr1\n\n@docs append, concat, concatMap, intersperse, unzip\n\n@docs sort, sortBy, sortWith\n\n@docs map2, map3, map4, map5\n\n","unions":[{"name":"PartitionResult","comment":" Return type for [`NotEmpty.List.partition`](NotEmpty.List#partition)\n\nWill be `NoMatches` when no elements in the list satisfy the test.\n\nWill be `OnlyMatches` when all elements in the list satisfy the test.\n\nWill be `Both` if there a both elements that do and don't satisfy the test.\nThe first list are the elements that satisfy the test and the second list are the elements that don't.\n\n","args":["a"],"cases":[["NoMatches",["NotEmpty.List.List a"]],["OnlyMatches",["NotEmpty.List.List a"]],["Both",["NotEmpty.List.List a","NotEmpty.List.List a"]]]}],"aliases":[{"name":"List","comment":" Not empty version of `List` ","args":["item"],"type":"( item, Internal.CoreTypes.CoreList item )"}],"values":[{"name":"all","comment":" Same as `List.all` ","type":"(a -> Basics.Bool) -> NotEmpty.List.List a -> Basics.Bool"},{"name":"any","comment":" Same as `List.any` ","type":"(a -> Basics.Bool) -> NotEmpty.List.List a -> Basics.Bool"},{"name":"append","comment":" Same as `List.append` ","type":"NotEmpty.List.List a -> NotEmpty.List.List a -> NotEmpty.List.List a"},{"name":"appendList","comment":" Appends a regular list to a not empty list\n\n    appendList ( singleton 1 ) [ 2, 3 ] == withHead 1 [ 2, 3 ]\n    appendList ( withHead 1 [ 2, 3 ] ) [ 4, 5 ] == withHead 1 [ 2, 3, 4, 5 ]\n\n","type":"NotEmpty.List.List a -> Internal.CoreTypes.CoreList a -> NotEmpty.List.List a"},{"name":"appendToList","comment":" Appends a not empty list to a regular list\n\n    appendToList [ 1, 2 ] ( singleton 3 ) == withHead 1 [ 2, 3 ]\n    appendToList [ 1, 2, 3 ] ( withHead 4 [ 5 ] ) == withHead 1 [ 2, 3, 4, 5 ]\n    appendToList [] ( withHead 1 [ 2, 3 ] ) == withHead 1 [ 2, 3 ]\n\n","type":"Internal.CoreTypes.CoreList a -> NotEmpty.List.List a -> NotEmpty.List.List a"},{"name":"concat","comment":" Same as `List.concat` ","type":"NotEmpty.List.List (NotEmpty.List.List a) -> NotEmpty.List.List a"},{"name":"concatMap","comment":" Same as `List.concatMap` ","type":"(a -> NotEmpty.List.List b) -> NotEmpty.List.List a -> NotEmpty.List.List b"},{"name":"cons","comment":" Add an element to the front of a not empty list.\n\n  cons 1 ( singleton 2 ) == withHead 1 [ 2 ]\n","type":"a -> NotEmpty.List.List a -> NotEmpty.List.List a"},{"name":"drop","comment":" Same as `List.drop` but will always include the last element\n\n    drop 2 ( withHead 1 [ 2, 3 ] ) == withHead 2 [ 3 ]\n    drop 0 ( withHead 1 [ 2, 3 ] ) == singleton 3\n\n","type":"Basics.Int -> NotEmpty.List.List a -> NotEmpty.List.List a"},{"name":"filter","comment":" Same as `List.filter` but will return Nothing if no elements satisfy the test\n\n    filter isEven ( withHead 1 [ 2, 3, 4, 5, 6 ] ) == Just ( withHead 2 [ 4, 6 ] )\n    filter isEven ( withHead 1 [ 3, 5 ] ) == Nothing\n\n","type":"(a -> Basics.Bool) -> NotEmpty.List.List a -> Maybe.Maybe (NotEmpty.List.List a)"},{"name":"filterMap","comment":" Same as `List.filterMap` but will return Nothing if all elements return Nothing\n\n    numbers1 : Maybe ( List Int )\n    numbers1 =\n      filterMap String.toInt ( withHead \"3\" [ \"hi\", \"12\", \"4th\", \"May\" ] )\n\n    numbers2 : Maybe ( List Int )\n    numbers2 =\n      filterMap String.toInt ( withHead \"hello\" [ \"world\" ] )\n\n    -- numbers1 == Just [3, 12]\n    -- numbers2 == Nothing\n\n","type":"(a -> Maybe.Maybe b) -> NotEmpty.List.List a -> Maybe.Maybe (NotEmpty.List.List b)"},{"name":"foldl","comment":" Same as `List.foldl` ","type":"(a -> b -> b) -> b -> NotEmpty.List.List a -> b"},{"name":"foldl1","comment":" Same as `List.foldl` but instead of supplying a start value you provide a function that produces the start value based on the first element\n\n  foldl1 (+) negate ( withHead 1 [ 2, 3 ] ) == 4\n  foldl1 (::) singleton ( withHead 1 [ 2, 3 ] ) == withHead 3 [ 2, 1 ]\n","type":"(a -> acc -> acc) -> (a -> acc) -> NotEmpty.List.List a -> acc"},{"name":"foldr","comment":" Same as `List.foldr` ","type":"(a -> b -> b) -> b -> NotEmpty.List.List a -> b"},{"name":"foldr1","comment":" Same as `List.foldl` but instead of supplying a start value you provide a function that produces the start value based on the last element\n\n  foldr1 (+) negate ( withHead 1 [ 2, 3 ] ) == 0\n  foldr1 (::) singleton ( withHead 1 [ 2, 3 ] ) == withHead 1 [ 2, 3 ]\n\n","type":"(a -> acc -> acc) -> (a -> acc) -> NotEmpty.List.List a -> acc"},{"name":"fromList","comment":" Convert a regular list into a not empty list, or Nothing if the list is empty\n\n    fromList [] == Nothing\n    fromList [ 1, 2, 3 ] == Just ( withHead 1 [ 2, 3 ] )\n","type":"Internal.CoreTypes.CoreList a -> Maybe.Maybe (NotEmpty.List.List a)"},{"name":"hasTail","comment":" Returns wether the list has a tail with elements\n\n    hasTail ( withHead 1 [ 2, 3 ] ) == True\n    hasTail ( singleton 1 ) == False\n    hasTail ( withHead 1 [] ) == False\n","type":"NotEmpty.List.List a -> Basics.Bool"},{"name":"head","comment":" Same as `List.head` but will always always return a value ","type":"NotEmpty.List.List a -> a"},{"name":"indexedMap","comment":" Same as `List.indexedMap` ","type":"(Basics.Int -> a -> b) -> NotEmpty.List.List a -> NotEmpty.List.List b"},{"name":"intersperse","comment":" Same as `List.intersperse` ","type":"a -> NotEmpty.List.List a -> NotEmpty.List.List a"},{"name":"last","comment":" Extract the last element from a not empty list.\n\n    last ( withHead 1 [ 2, 3 ] ) == 3\n    last ( singleton 1 ) == 1\n","type":"NotEmpty.List.List a -> a"},{"name":"length","comment":" Same as `List.length` ","type":"NotEmpty.List.List a -> Basics.Int"},{"name":"map","comment":" Same as `List.map` ","type":"(a -> b) -> NotEmpty.List.List a -> NotEmpty.List.List b"},{"name":"map2","comment":" Same as `List.map2` ","type":"(a -> b -> result) -> NotEmpty.List.List a -> NotEmpty.List.List b -> NotEmpty.List.List result"},{"name":"map3","comment":" Same as `List.map3` ","type":"(a -> b -> c -> result) -> NotEmpty.List.List a -> NotEmpty.List.List b -> NotEmpty.List.List c -> NotEmpty.List.List result"},{"name":"map4","comment":" Same as `List.map4` ","type":"(a -> b -> c -> d -> result) -> NotEmpty.List.List a -> NotEmpty.List.List b -> NotEmpty.List.List c -> NotEmpty.List.List d -> NotEmpty.List.List result"},{"name":"map5","comment":" Same as `List.map5` ","type":"(a -> b -> c -> d -> e -> result) -> NotEmpty.List.List a -> NotEmpty.List.List b -> NotEmpty.List.List c -> NotEmpty.List.List d -> NotEmpty.List.List e -> NotEmpty.List.List result"},{"name":"maximum","comment":" Same as `List.maximum` but will always return a value ","type":"NotEmpty.List.List comparable -> comparable"},{"name":"member","comment":" Same as `List.member` ","type":"a -> NotEmpty.List.List a -> Basics.Bool"},{"name":"minimum","comment":" Same as `List.minimum` but will always return a value ","type":"NotEmpty.List.List comparable -> comparable"},{"name":"partition","comment":" Same as `List.partition` but will return a [`PartitionResult`](NotEmpty.List#PartitionResult) since either but not both lists could be empty. ","type":"(a -> Basics.Bool) -> NotEmpty.List.List a -> NotEmpty.List.PartitionResult a"},{"name":"product","comment":" Same as `List.product` ","type":"NotEmpty.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\nWill always include the low value.\n\n    toList ( range 3 6 ) == [ 3, 4, 5, 6 ]\n    toList ( range 3 3 ) == [ 3 ]\n    toList ( range 6 3 ) == [ 6 ]\n","type":"Basics.Int -> Basics.Int -> NotEmpty.List.List Basics.Int"},{"name":"repeat","comment":" Create a not empty list with *n* copies of a value.\n\nWill always include at least 1 value.\n\n    toList ( repeat 4 \"Value\" ) == [ \"Value\", \"Value\", \"Value\", \"Value\" ]\n    toList ( repeat 0 \"Test\" ) == [ \"Test\" ]\n","type":"Basics.Int -> a -> NotEmpty.List.List a"},{"name":"reverse","comment":" Same as `List.reverse` ","type":"NotEmpty.List.List a -> NotEmpty.List.List a"},{"name":"singleton","comment":" A not empty list containing only the given value.\n\n    toList ( singleton \"a\" ) == [ \"a\" ]\n","type":"a -> NotEmpty.List.List a"},{"name":"sort","comment":" Same as `List.sort` ","type":"NotEmpty.List.List comparable -> NotEmpty.List.List comparable"},{"name":"sortBy","comment":" Same as `List.sortBy` ","type":"(a -> comparable) -> NotEmpty.List.List a -> NotEmpty.List.List a"},{"name":"sortWith","comment":" Same as `List.sortWith` ","type":"(a -> a -> Basics.Order) -> NotEmpty.List.List a -> NotEmpty.List.List a"},{"name":"sum","comment":" Same as `List.sum` ","type":"NotEmpty.List.List number -> number"},{"name":"tail","comment":" Same as `List.tail` but will always return a value\n\n    tail ( withHead 1 [ 2, 3 ] ) == [ 2, 3 ]\n    tail ( singleton 1 ) == []\n","type":"NotEmpty.List.List a -> Internal.CoreTypes.CoreList a"},{"name":"take","comment":" Same as `List.take` but will always include the first element\n\n    take 2 ( withHead 1 [ 2, 3 ] ) == withHead 1 [ 2 ]\n    take 0 ( withHead 1 [ 2, 3 ] ) == singleton 1\n\n","type":"Basics.Int -> NotEmpty.List.List a -> NotEmpty.List.List a"},{"name":"toList","comment":" Convert a not empty list into a regular list\n\n  toList ( withHead 1 [ 2, 3 ] ) == [ 1, 2, 3 ]\n  toList ( singleton 1 ) == [ 1 ]\n","type":"NotEmpty.List.List a -> Internal.CoreTypes.CoreList a"},{"name":"unCons","comment":" Deconstruct a not empty list into it's head and tail\n\n    unCons ( singleton 5 ) = ( 5, [] )\n    unCons ( withHead 1 [ 2, 3 ] ) = ( 1, [ 2, 3 ] )\n\n","type":"NotEmpty.List.List a -> ( a, Internal.CoreTypes.CoreList a )"},{"name":"unzip","comment":" Same as `List.unzip` ","type":"NotEmpty.List.List ( a, b ) -> ( NotEmpty.List.List a, NotEmpty.List.List b )"},{"name":"withHead","comment":" A not empty list with the given head and tail\n\n    ls = withHead 5 [ 4, 3 ]\n    toList ls == [ 5, 4, 3 ]\n    head ls == 5\n    tail ls == [ 4, 3 ]\n","type":"a -> Internal.CoreTypes.CoreList a -> NotEmpty.List.List a"}],"binops":[]},{"name":"NotEmpty.Set","comment":"\n@docs Set\n\n# Create\n\n@docs singleton, withValue, fromList, fromListWithValue\n\n# Transforming from and to regular sets\n\n@docs fromSet, toSet\n\n# New functions\n\n@docs head, last, tail, hasTail\n\n# Modified functions\n\n@docs remove, filter, diff, intersect\n\n# Unchanged functions\n\n@docs member, insert, size\n\n@docs map, foldl, foldr\n\n@docs toList, union\n\n","unions":[],"aliases":[{"name":"Set","comment":" Not empty version of `Set` ","args":["item"],"type":"( item, Set.Set item )"}],"values":[{"name":"diff","comment":" Same as `Set.diff` but will return Nothing if the resulting set is empty\n\n    diff ( fromListWithValue 1 [ 2, 3 ] ) ( singleton 1 ) == Just ( fromListWithValue 2 2 [ ( 3, 3 ) ] )\n    diff ( singleton 1 ) ( singleton 1 ) == Nothing\n    diff ( singleton 2 ) ( singleton 1 ) == Just ( singleton 2 )\n","type":"NotEmpty.Set.Set comparable -> NotEmpty.Set.Set comparable -> Maybe.Maybe (NotEmpty.Set.Set comparable)"},{"name":"filter","comment":" Same as `Set.filter` but will return Nothing if no values satisfy the test\n\n    filter isKeyEven ( fromListWithValue 1 [ 2, 3 ] ) == Just ( fromListWithValue 2 [] )\n    filter isKeyEven ( singleton 1 ) == Nothing\n","type":"(comparable -> Basics.Bool) -> NotEmpty.Set.Set comparable -> Maybe.Maybe (NotEmpty.Set.Set comparable)"},{"name":"foldl","comment":" Same as `Set.foldl` ","type":"(a -> b -> b) -> b -> NotEmpty.Set.Set a -> b"},{"name":"foldr","comment":" Same as `Set.foldr` ","type":"(a -> b -> b) -> b -> NotEmpty.Set.Set a -> b"},{"name":"fromList","comment":" Same as `Set.fromList` except using a [`NotEmpty.List`](NotEmpty.List#List) ","type":"NotEmpty.List.List comparable -> NotEmpty.Set.Set comparable"},{"name":"fromListWithValue","comment":" Same as [`withValue`](NotEmpty.Set#withValue) but with a list instead of a set ","type":"comparable -> List.List comparable -> NotEmpty.Set.Set comparable"},{"name":"fromSet","comment":" Convert a regular set into a not empty set, or Nothing if the set is empty\n\n    fromSet ( Set.fromList [] ) == Nothing\n    fromSet ( Set.fromList [ 1, 2, 3 ] ) == Just ( fromListWithValue 1 [ 2, 3 ] )\n","type":"Set.Set comparable -> Maybe.Maybe (NotEmpty.Set.Set comparable)"},{"name":"hasTail","comment":" Returns wether the set has a tail with elements\n\n    hasTail ( fromListWithValue 1 [ 2, 3 ] ) == True\n    hasTail ( singleton 1 ) == False\n    hasTail ( fromListWithHead 1 [] ) == False\n","type":"NotEmpty.Set.Set a -> Basics.Bool"},{"name":"head","comment":" Extract the first value from a not empty set.\n\n    head ( fromListWithValue 1 [ 2, 3 ] ) == 1\n    head ( singleton 1 ) == 1\n","type":"NotEmpty.Set.Set a -> a"},{"name":"insert","comment":" Same as `Set.insert` ","type":"comparable -> NotEmpty.Set.Set comparable -> NotEmpty.Set.Set comparable"},{"name":"intersect","comment":" Same as `Set.intersect` but will return Nothing if the resulting set is empty\n\n    intersect ( fromListWithValue 1 [ 2, 3 ] ) ( singleton 1 ) == Just ( fromListWithValue 1 1 [] )\n    intersect ( singleton 1 ) ( singleton 1 ) == Just ( singleton 1 )\n    intersect ( singleton 2 ) ( singleton 1 ) == Nothing\n","type":"NotEmpty.Set.Set comparable -> NotEmpty.Set.Set comparable -> Maybe.Maybe (NotEmpty.Set.Set comparable)"},{"name":"last","comment":" Extract the last value from a not empty set.\n\n    head ( fromListWithValue 1 [ 2, 3 ] ) == 3\n    head ( singleton 1 ) == 1\n","type":"NotEmpty.Set.Set a -> a"},{"name":"map","comment":" Same as `Set.map` ","type":"(comparable1 -> comparable2) -> NotEmpty.Set.Set comparable1 -> NotEmpty.Set.Set comparable2"},{"name":"member","comment":" Same as `Set.member` ","type":"comparable -> NotEmpty.Set.Set comparable -> Basics.Bool"},{"name":"remove","comment":" Same as `Set.remove` but will return Nothing if the last value is removed\n\n    remove 1 ( fromListWithValue 1 [ 2, 3 ] ) == Just ( fromListWithValue 2 [ 3 ] )\n    remove 1 ( singleton 1 ) == Nothing\n    remove 2 ( singleton 1 ) == Just ( singleton 1 )\n","type":"comparable -> NotEmpty.Set.Set comparable -> Maybe.Maybe (NotEmpty.Set.Set comparable)"},{"name":"singleton","comment":" Create a non empty set with one value. ","type":"a -> NotEmpty.Set.Set a"},{"name":"size","comment":" Same as `Set.size` ","type":"NotEmpty.Set.Set a -> Basics.Int"},{"name":"tail","comment":" Returns the elements after the first value as a regular set\n\n    tail ( fromListWithValue 1 [ 2, 3 ] ) == Set.fromList [ 2, 3 ]\n    tail ( singleton 1 ) == Set.fromList []\n","type":"NotEmpty.Set.Set a -> Set.Set a"},{"name":"toList","comment":" Same as `Set.toList` ","type":"NotEmpty.Set.Set a -> NotEmpty.List.List a"},{"name":"toSet","comment":" Convert a not empty set into a regular set\n\n    toSet ( fromListWithValue 1 [ 2, 3 ] ) == Set.fromList [ 1, 2, 3 ]\n    toSet ( singleton 1 ) == Set.singleton 1\n","type":"NotEmpty.Set.Set comparable -> Set.Set comparable"},{"name":"union","comment":" Same as `Set.union` ","type":"NotEmpty.Set.Set comparable -> NotEmpty.Set.Set comparable -> NotEmpty.Set.Set comparable"},{"name":"withValue","comment":" Create a non empty set from a regular set and a given value.\n\nIn contrast to [`fromSet`](NotEmpty.Set#fromSet) this will always return a value since there is always at least 1 value.\n\n    set = withValue 5 ( Set.fromList [ 4, 3 ] )\n    toSet set == Set.fromList [ 3, 4, 5 ]\n","type":"comparable -> Set.Set comparable -> NotEmpty.Set.Set comparable"}],"binops":[]},{"name":"NotEmpty.String","comment":"\n# Strings\n@docs String, fromString, toString, length, reverse, repeat, replace\n\n# Building and Splitting\n@docs append, appendString, appendToString, concat, split, join, words, lines\n\n# Get Substrings\n@docs slice, left, right, dropLeft, dropRight\n\n# Check for Substrings\n@docs contains, startsWith, endsWith, indexes, indices\n\n# Int Conversions\n@docs toInt, fromInt\n\n# Float Conversions\n@docs toFloat, fromFloat\n\n# Char Conversions\n@docs fromChar, cons, consString, uncons, head, tail\n\n# List Conversions\n@docs toList, fromList\n\n# Formatting\nCosmetic operations such as padding with extra characters or trimming whitespace.\n\n@docs toUpper, toLower, pad, padLeft, padRight, trim, trimLeft, trimRight\n\n# Higher-Order Functions\n@docs map, filter, foldl, foldr, any, all\n","unions":[],"aliases":[{"name":"String","comment":" Not empty version of `String` ","args":[],"type":"( Char.Char, Internal.CoreTypes.CoreString )"}],"values":[{"name":"all","comment":" Same as String.all ","type":"(Char.Char -> Basics.Bool) -> NotEmpty.String.String -> Basics.Bool"},{"name":"any","comment":" Same as String.any ","type":"(Char.Char -> Basics.Bool) -> NotEmpty.String.String -> Basics.Bool"},{"name":"append","comment":" Same as String.append ","type":"NotEmpty.String.String -> NotEmpty.String.String -> NotEmpty.String.String"},{"name":"appendString","comment":" Append a regular string to a not empty string ","type":"NotEmpty.String.String -> Internal.CoreTypes.CoreString -> NotEmpty.String.String"},{"name":"appendToString","comment":" Append a not empty string to a regular string ","type":"Internal.CoreTypes.CoreString -> NotEmpty.String.String -> NotEmpty.String.String"},{"name":"concat","comment":" Same as String.concat ","type":"NotEmpty.List.List NotEmpty.String.String -> NotEmpty.String.String"},{"name":"cons","comment":" Same as String.cons ","type":"Char.Char -> NotEmpty.String.String -> NotEmpty.String.String"},{"name":"consString","comment":" Create a not empty string from a char and a regular string ","type":"Char.Char -> Internal.CoreTypes.CoreString -> NotEmpty.String.String"},{"name":"contains","comment":" Same as String.contains ","type":"NotEmpty.String.String -> NotEmpty.String.String -> Basics.Bool"},{"name":"dropLeft","comment":" Same as String.dropLeft ","type":"Basics.Int -> NotEmpty.String.String -> Maybe.Maybe NotEmpty.String.String"},{"name":"dropRight","comment":" Same as String.dropRight ","type":"Basics.Int -> NotEmpty.String.String -> Maybe.Maybe NotEmpty.String.String"},{"name":"endsWith","comment":" Same as String.endsWith ","type":"NotEmpty.String.String -> NotEmpty.String.String -> Basics.Bool"},{"name":"filter","comment":" Same as String.filter ","type":"(Char.Char -> Basics.Bool) -> NotEmpty.String.String -> Maybe.Maybe NotEmpty.String.String"},{"name":"foldl","comment":" Same as String.foldl ","type":"(Char.Char -> b -> b) -> b -> NotEmpty.String.String -> b"},{"name":"foldr","comment":" Same as String.foldr ","type":"(Char.Char -> b -> b) -> b -> NotEmpty.String.String -> b"},{"name":"fromChar","comment":" Same as String.fromChar ","type":"Char.Char -> NotEmpty.String.String"},{"name":"fromFloat","comment":" Same as String.fromFloat ","type":"Basics.Float -> NotEmpty.String.String"},{"name":"fromInt","comment":" Same as String.fromInt ","type":"Basics.Int -> NotEmpty.String.String"},{"name":"fromList","comment":" Same as String.fromList, but takes a not empty list ","type":"NotEmpty.List.List Char.Char -> NotEmpty.String.String"},{"name":"fromString","comment":" Convert a regular string into a not empty string, or Nothing if the string is empty\n\n    fromString \"\" == Nothing\n    fromString \"hello\" == Just ( consString 'h' \"ello\" )\n","type":"Internal.CoreTypes.CoreString -> Maybe.Maybe NotEmpty.String.String"},{"name":"head","comment":" Get the first character from a not empty string\n\n  head ( consString 'h' \"ello\" ) == 'h'\n","type":"NotEmpty.String.String -> Char.Char"},{"name":"indexes","comment":" Same as String.indexes ","type":"NotEmpty.String.String -> NotEmpty.String.String -> List.List Basics.Int"},{"name":"indices","comment":" Alias for `indexes`. ","type":"NotEmpty.String.String -> NotEmpty.String.String -> List.List Basics.Int"},{"name":"join","comment":" Same as String.join ","type":"Internal.CoreTypes.CoreString -> NotEmpty.List.List NotEmpty.String.String -> NotEmpty.String.String"},{"name":"left","comment":" Same as String.left but will take at least 1 character ","type":"Basics.Int -> NotEmpty.String.String -> NotEmpty.String.String"},{"name":"length","comment":" Same as String.length ","type":"NotEmpty.String.String -> Basics.Int"},{"name":"lines","comment":" Same as String.lines, returns regular strings ","type":"NotEmpty.String.String -> List.List Internal.CoreTypes.CoreString"},{"name":"map","comment":" Same as String.map ","type":"(Char.Char -> Char.Char) -> NotEmpty.String.String -> NotEmpty.String.String"},{"name":"pad","comment":" Same as String.pad ","type":"Basics.Int -> Char.Char -> NotEmpty.String.String -> NotEmpty.String.String"},{"name":"padLeft","comment":" Same as String.padLeft ","type":"Basics.Int -> Char.Char -> NotEmpty.String.String -> NotEmpty.String.String"},{"name":"padRight","comment":" Same as String.padRight ","type":"Basics.Int -> Char.Char -> NotEmpty.String.String -> NotEmpty.String.String"},{"name":"repeat","comment":" Same as String.repeat but the string is repeated at least once ","type":"Basics.Int -> NotEmpty.String.String -> NotEmpty.String.String"},{"name":"replace","comment":" Same as String.replace ","type":"NotEmpty.String.String -> NotEmpty.String.String -> NotEmpty.String.String -> NotEmpty.String.String"},{"name":"reverse","comment":" Same as String.reverse ","type":"NotEmpty.String.String -> NotEmpty.String.String"},{"name":"right","comment":" Same as String.right but will take at least 1 character ","type":"Basics.Int -> NotEmpty.String.String -> NotEmpty.String.String"},{"name":"slice","comment":" Same as String.slice ","type":"Basics.Int -> Basics.Int -> NotEmpty.String.String -> Maybe.Maybe NotEmpty.String.String"},{"name":"split","comment":" Same as String.split, returns regular strings ","type":"NotEmpty.String.String -> NotEmpty.String.String -> NotEmpty.List.List Internal.CoreTypes.CoreString"},{"name":"startsWith","comment":" Same as String.startsWith ","type":"NotEmpty.String.String -> NotEmpty.String.String -> Basics.Bool"},{"name":"tail","comment":" Get the tail from a not empty string\n\n  tail ( consString 'h' \"ello\" ) == \"ello\"\n","type":"NotEmpty.String.String -> Internal.CoreTypes.CoreString"},{"name":"toFloat","comment":" Same as String.toFloat ","type":"NotEmpty.String.String -> Maybe.Maybe Basics.Float"},{"name":"toInt","comment":" Same as String.toInt ","type":"NotEmpty.String.String -> Maybe.Maybe Basics.Int"},{"name":"toList","comment":" Same as String.toList, returns a not empty list ","type":"NotEmpty.String.String -> NotEmpty.List.List Char.Char"},{"name":"toLower","comment":" Same as String.toLower ","type":"NotEmpty.String.String -> NotEmpty.String.String"},{"name":"toString","comment":" Convert a not empty string into a regular string\n\n  toString ( consString 'h' \"ello\" ) == \"hello\"\n  toString ( consString 'a' \"\" ) == \"a\"\n","type":"NotEmpty.String.String -> Internal.CoreTypes.CoreString"},{"name":"toUpper","comment":" Same as String.toUpper ","type":"NotEmpty.String.String -> NotEmpty.String.String"},{"name":"trim","comment":" Same as String.trim ","type":"NotEmpty.String.String -> Maybe.Maybe NotEmpty.String.String"},{"name":"trimLeft","comment":" Same as String.trimLeft ","type":"NotEmpty.String.String -> Maybe.Maybe NotEmpty.String.String"},{"name":"trimRight","comment":" Same as String.trimRight ","type":"NotEmpty.String.String -> Maybe.Maybe NotEmpty.String.String"},{"name":"uncons","comment":" Same as String.uncons, but always returns a value ","type":"NotEmpty.String.String -> ( Char.Char, Internal.CoreTypes.CoreString )"},{"name":"words","comment":" Same as String.words but will not return empty words ","type":"NotEmpty.String.String -> List.List NotEmpty.String.String"}],"binops":[]}]