[{"name":"KeysDict","comment":"\n@docs KeysDict\n\n@docs Uniqueness, unique\n\n## create\n@docs empty, fromDict, fromList, decode\n\n## scan\n@docs equal, access, emptyOrMore, size\n\n## in\n@docs putIn, union\n\n## out\n@docs remove\n\n## shape\n@docs fold, map, toDict, encode\n","unions":[{"name":"KeysDict","comment":" Want to look up values from many directions?\n\n> You want the pair where `🗝️` is `1` and the pair where `🔑` is `0`?\n\n      → < 🔑= 0, 🏠= 🍐, 🗝️= 2 >\n        < 🔑= 2, 🏠= 🌳, 🗝️= 0 >\n        < 🔑= 1, 🏠= 🍐, 🗝️= 1 > ←\n\n        (🔑 & 🗝️ are unique)\n\n> Going through while checking every pair, if `🗝️` is equal, then, if `🔑` is equal.\n\n        🔑= 1, 🗝️= 1 where 🗝️ is 1    🔑= 0, 🗝️= 2 where 🔑 is 0\n\nLike [assoc-list](https://github.com/pzp1997/assoc-list), a `KeysDict` allows union types.\n\n## Example: cased letters\n    type alias CasedLetter=\n      { lowercase: Char\n      , uppercase: Char\n      }\n\n    casedLetters: KeysDict CasedLetter\n    casedLetters=\n      KeysDict.empty [ unique .lowercase, unique .uppercase ]\n      |>KeysDict.putIn { lowercase= 'a', uppercase= 'A' }\n      |>KeysDict.putIn { lowercase= 'b', uppercase= 'B' }\n      |>KeysDict.putIn { lowercase= 'c', uppercase= 'C' }\n\n    uppercase char=\n      KeysDict.access .lowercase char lowerUppercaseLetters\n      |>Maybe.map .uppercase\n","args":["value"],"cases":[]},{"name":"Uniqueness","comment":" Ensures, that there is not more than one value in the `KeysDict`, where a given condition is `True` (e.g. a given key being equal to a value)\n\nThat sounds a bit complicated, so let's look at some examples.\n\n    listWithoutKeys= KeysDict.empty []--no Uniqueness\n\n    uniqueInCasedLetter=\n      []\n      |>unique .inAlphabet\n      |>unique .lowercase\n      |>unique .uppercase\n    \n    letters=\n      KeysDict.fromList uniqueInCasedLetter\n        [ { inAlphabet= 0, lowercase= 'a', uppercase= 'A' }\n        ]\n","args":["value"],"cases":[]}],"aliases":[],"values":[{"name":"access","comment":" `Just` the value in which `key` is present in the `KeysDict`,\nif no value with the `key` is found `Nothing`.\n\n    casedLetters=\n      KeysDict.empty [ unique .lowercase, unique .uppercase ]\n      |>KeysDict.putIn { lowercase= 'a', uppercase= 'A' }\n      |>KeysDict.putIn { lowercase= 'b', uppercase= 'B' }\n\n    lowercase char=\n      KeysDict.access .uppercase char\n        casedLetters\n      |>Maybe.map .lowercase\n    uppercase char=\n      KeysDict.access .lowercase char\n        casedLetters\n      |>Maybe.map .uppercase\n\n**Note**: If `accessKey` is not a key,\n`access` will find the most recently inserted value where `accessKey` of the value is `key`.\n\n    KeysDict.empty [ unique .lowercase, unique .uppercase ]\n    |>KeysDict.putIn { rating= 0.5, lowercase= 'a', uppercase= 'A' }\n    |>KeysDict.putIn { rating= 0.5, lowercase= 'b', uppercase= 'B' }\n    |>KeysDict.access .rating 0.5\n> `{ rating= 0.5, lowercase= 'b', uppercase= 'B' }`\n","type":"(value -> key) -> key -> KeysDict.KeysDict value -> Maybe.Maybe value"},{"name":"decode","comment":" A `Json.Decode.Decoder` for `KeysDict`s encoded by `encode`.\n\nThe order of insertion is not reconstructed (see `equal`)\n\n    type alias NamedNumber=\n      { number: Int\n      , name: String\n      }\n    \n    decodeNamedNumber=\n      Decode.map NamedNumber\n        (\\{ number, name }->\n          Decode.object\n            [ ( \"number\", Decode.int number )\n            , ( \"name\", Decode.string name )\n            ]\n        )\n\n    \"\"\"\n    [\n     {\n      \\\"left\\\": 2,\n      \\\"right\\\": \"two\"\n     },\n     {\n      \\\"left\\\": 1,\n      \\\"right\\\": \"one\"\n     }\n    ]\n    \"\"\"\n    |>Decode.decodeString\n        (KeysDict.decode [ unique .number, unique .name ]\n          decodeNamedNumber\n        )\n\n> `Ok (ValuesWithKeys [ { number= 1, name= \"one\" }, { number= 2, name= \"two\" } ])`\n> = a `KeysDict`\n","type":"List.List (KeysDict.Uniqueness value) -> Json.Decode.Decoder value -> Json.Decode.Decoder (KeysDict.KeysDict value)"},{"name":"empty","comment":" A `KeysDict` with no values inside.\n","type":"List.List (KeysDict.Uniqueness value) -> KeysDict.KeysDict value"},{"name":"emptyOrMore","comment":" `ifEmpty` if the `KeysDict` contains no values,\nelse `ifMore` with the most recently inserted value followed by a `KeysDict` with the other values.\n\nIt has a very similar use case to a `case of` on a `List`.\n\n    isEmpty=\n      KeysDict.emptyOrMore\n        { ifEmpty= True\n        , ifMore= \\_ _-> False\n        }\n    mostRecent=\n      KeysDict.emptyOrMore\n        { ifMore= \\value _-> Just value\n        , ifEmpty= Nothing\n        }\n    removeMostRecent keysDict=\n      keysDict\n      |>KeysDict.emptyOrMore\n          { ifMore= \\_ rest-> rest\n          , ifEmpty= KeysDict\n          }\n","type":"{ ifEmpty : result, ifMore : value -> KeysDict.KeysDict value -> result } -> KeysDict.KeysDict value -> result"},{"name":"encode","comment":" Convert a `KeysDict` to a `Json.Encode.Value`.\n\n    someKeysDict=\n      KeysDict.empty\n      |>KeysDict.putIn ( 1, 11 )\n      |>KeysDict.putIn ( 2, 22 )\n    Encode.encode 1\n      (KeysDict.encode\n        Encode.int Encode.int\n        someKeysDict\n      )\n\n    \"\"\"\n    [\n     {\n      \\\"left\\\": 2,\n      \\\"right\\\": 22\n     },\n     {\n      \\\"left\\\": 1,\n      \\\"right\\\": 11\n     }\n    ]\n    \"\"\"\n","type":"(value -> Json.Encode.Value) -> KeysDict.KeysDict value -> Json.Encode.Value"},{"name":"equal","comment":" Using built-in (==) equality is often not useful in the context of association-dicts.\n\nDo these 2 `KeysDict`s have the same size and identical values (ignoring insertion order)?\n\n    letterCodes=\n      KeysDict.fromList [ unique .letter, unique .code ]\n        [ { letter= 'a', code= 97 }\n        , { letter= 'b', code= 98 }\n        ]\n    fancyCompetingLetterCodes=\n      KeysDict.empty [ unique .code, unique .letter ]\n      |>KeysDict.putIn { code= 98, letter= 'b' }\n      |>KeysDict.putIn { code= 97, letter= 'a' }\n    \n    KeysDict.equal\n      letterCodes\n      fancyCompetingLetterCodes\n> `True`\n\n    lettersAndCodesInAlphabet\n","type":"KeysDict.KeysDict value -> KeysDict.KeysDict value -> Basics.Bool"},{"name":"fold","comment":" Reduce the values\nfrom most recently putIned to least recently inserted.\n\nA fold in the other direction doesn't exist, as association-`Dict`s should rarely rely on order (see `equal`).\n\n    brackets=\n      KeysDict.empty\n      |>KeysDict.putIn ( '(', ')' )\n      |>KeysDict.putIn ( '{', '}' )\n\n    openingAndClosing=\n      brackets\n      |>KeysDict.fold\n          (\\( left, right ) acc->\n            acc++[ String.fromList [ left, right ] ]\n          )\n          []\n> `[ \"{}\", \"()\" ]`\n","type":"(value -> acc -> acc) -> acc -> KeysDict.KeysDict value -> acc"},{"name":"fromDict","comment":" Create a `KeysDict` from a association-`Dict`.\nIf multiple equal keys or values are present, the value **first** in the `Dict` is **prefered** (see `putIn`).\n    \n    lowerToUpperLetters=\n      AssocList.empty\n      |>AssocList.insert 'a' 'A'\n      |>AssocList.insert 'b' 'B'\n\n    lowerUpperLetters=\n      lowerToUpperLetters\n      |>KeysDict.fromDict\n          (\\k v-> { lowercase= k, uppercase= v })\n          [ unique .lowercase, unique .uppercase ]\n","type":"(key -> dictValue -> value) -> List.List (KeysDict.Uniqueness value) -> AssocList.Dict key dictValue -> KeysDict.KeysDict value"},{"name":"fromList","comment":" Create a `KeysDict` _conveniently_ from values.\nIf right or left values are given multiple times, the value **first** in the `List` is **prefered** (see `putIn`).\n    \n    KeysDict.fromList [ unique .lowercase, unique .uppercase ]\n      [ { lowercase= 'b', uppercase= 'B' } --put in\n      , { lowercase= 'a', uppercase= 'A' } --put in\n      , { lowercase= 'b', uppercase= 'C' }\n          --ignored, as the left value already exists\n      , { lowercase= 'c', uppercase= 'A' }\n          --ignored, as the right value already exists\n      , { lowercase= 'c', uppercase= 'C' } --put in\n      ]\n","type":"List.List (KeysDict.Uniqueness value) -> List.List value -> KeysDict.KeysDict value"},{"name":"map","comment":" Map all values.\n\n    digitNames=\n      KeysDict.empty .number .name\n      |>KeysDict.putIn { number= 0, name= \"zero\" }\n      |>KeysDict.putIn { number= 1, name= \"one\" }\n\n    mathSymbolNames=\n      digitNames\n      |>KeysDict.map .symbol .name\n          (\\{ number, name }->\n            { symbol= String.fromInt number, name= name }\n          )\n      |>KeysDict.putIn { symbol= \"+\", name= \"plus\" }\n","type":"(value -> resultValue) -> List.List (KeysDict.Uniqueness resultValue) -> KeysDict.KeysDict value -> KeysDict.KeysDict resultValue"},{"name":"putIn","comment":" Put in a value. This can't be a function or a json.\n\nIf a **key** is already **present**, the `KeysDict` is **unchanged**.\n\n    KeysDict.empty [ unique .lowercase, unique .uppercase ]\n    |>KeysDict.putIn { lowercase= 'b', uppercase= 'B', rating= 0.5 }\n        --put in \n    |>KeysDict.putIn { lowercase= 'a', uppercase= 'A', rating= 0.5 }\n        --put in, because rating is not a key\n    |>KeysDict.putIn { lowercase= 'b', uppercase= 'C', rating= 0 }\n        --ignored, the left value already exists\n    |>KeysDict.putIn { lowercase= 'c', uppercase= 'A', rating= 0 }\n        --ignored, the right value already exists\n    |>KeysDict.putIn { lowercase= 'c', uppercase= 'C', rating= 0.6 }\n        --put in\n","type":"value -> KeysDict.KeysDict value -> KeysDict.KeysDict value"},{"name":"remove","comment":" Remove the value at the `key`.\nIf **the key does not exist**, the `KeysDict` is **unchanged**\n\n    openClosedBrackets=\n      KeysDict.empty .open .closed\n      |>KeysDict.putIn { open= \"(\", closed= \")\" }\n\n    openClosedBrackets\n    |>KeysDict.remove .open \")\" \n        --unchanged, \")\" is not a open value\n    |>KeysDict.remove .open \"(\"\n> `KeysDict.empty`\n\n    openClosedBrackets\n    |>KeysDict.remove .closed \"(\"\n        --unchanged, \"(\" is not a closed value\n    |>KeysDict.remove .closed \")\"\n> `KeysDict.empty`\n\n**Notice:** If you don't specify `accessValue` as `left` or `right`, it acts as a normal filter\n\n    KeysDict.empty .open .closed\n    |>KeysDict.putIn { open= \"(\", closed= \")\", meaning= Nothing }\n    |>KeysDict.putIn { open= \"[\", closed= \"]\", meaning= Just (List Element) }\n    |>KeysDict.putIn { open= \"<, closed= \">\", meaning= Nothing }\n    |>KeysDict.remove .meaning Nothing\n","type":"(value -> key) -> key -> KeysDict.KeysDict value -> KeysDict.KeysDict value"},{"name":"size","comment":" How many values there are in a `KeysDict`.\n\n    KeysDict.fromList [ unique .number, unique .following ]\n      (List.map (\\i-> { number= i, following= i+1 })\n        (List.range 0 41)\n      )\n    |>KeysDict.size\n> `42`\n","type":"KeysDict.KeysDict value -> Basics.Int"},{"name":"toDict","comment":" Convert a `KeysDict` to an association-`Dict`.\n\n    casedLetters=\n      KeysDict.fromList .lowercase .uppercase\n        [ { uppercase= 'A', lowercase= 'a' }\n        , { uppercase= 'B', lowercase= 'b' }\n        ]\n    lowerFromUppercase=\n      KeysDict.toDict .uppercase .lowercase\n        casedLetters\n","type":"(value -> dictKey) -> (value -> dictValue) -> KeysDict.KeysDict value -> AssocList.Dict dictKey dictValue"},{"name":"union","comment":" Combine 2 `KeysDict`s, so that the values in `toInsert` are put into `preferred`.\nIf a value on the left or right is present, prefer the last `KeysDict` (see `putIn`).\n\n    numberNamedOperators=\n      KeysDict.fromList .name .operator\n        [ { operator= '+', name= \"plus\" }\n        , { operator= '-', name= \"minus\" }\n        ]\n    customNamedOperators=\n      KeysDict.fromList .operator .name\n        [ { operator= '∧', name= \"and\" }\n        , { operator= '∨', name= \"or\" }\n        , { operator= '-', name= \"negate\" }\n        ]\n    validNamedOperators=\n      KeysDict.union\n        custumNamedOperators --has a '-' left\n        numberOperatorNames --preferred → its '-'-value is put in\n","type":"KeysDict.KeysDict value -> KeysDict.KeysDict value -> KeysDict.KeysDict value"},{"name":"unique","comment":" `accessKey` returns a value, which will be unique in a `KeysDict`.\n\n    KeysDict.empty [ unique .lowercase, unique .uppercase ]\n    |>KeysDict.putIn { lowercase= 'a', uppercase= 'A' }--put in\n    |>KeysDict.putIn { lowercase= 'a', uppercase= 'B' }\n      --checked values: .lowercase exists already! \n      -->KeysDict is unchanged\n","type":"(value -> key) -> KeysDict.Uniqueness value"}],"binops":[]}]