[{"name":"Pair","comment":"\n@docs Pair\n\n## create\nthrough the constructor or through\n\n@docs decode\n\n## access\n@docs leftIn, rightIn\n\n## shape\n@docs mapLeft, mapRight, map, encode\n","unions":[],"aliases":[{"name":"Pair","comment":" `( left, right )` as a value-pair.\n\n    openClosedCurlyBracePair=\n      ( '{', '}' )\n","args":["left","right"],"type":"( left, right )"}],"values":[{"name":"decode","comment":" A `Json.Decode.Decoder` for `Pair`s, encoded by `encodePair`\n    \n    \"\"\"\n    {\n     \\\"left\\\": 1,\n     \\\"right\\\": 11\n    }\n    \"\"\"\n    |>Decode.decodeString\n        (Pair.decode Decode.int Decode.int)\n\n> `Ok ( 1, 11 )`\n","type":"Json.Decode.Decoder left -> Json.Decode.Decoder right -> Json.Decode.Decoder (Pair.Pair left right)"},{"name":"encode","comment":" Convert a `Pair` to a `Json.Encode.Value`.\n\n    Encode.encode 1\n      (Pair.encode\n        Encode.int Encode.int\n        ( 1, 11 )\n      )\n\n    \"\"\"\n    {\n     \\\"left\\\": 1,\n     \\\"right\\\": 11\n    }\n    \"\"\"\n","type":"(left -> Json.Encode.Value) -> (right -> Json.Encode.Value) -> Pair.Pair left right -> Json.Encode.Value"},{"name":"leftIn","comment":" access the left value in a `Pair`.\n\n    openClosedCurlyBracePair=\n      ( '{', '}' )\n    openCurly= leftIn openClosedCurlyBracePair\n","type":"Pair.Pair left right -> left"},{"name":"map","comment":" map the `right` value in a `Pair`\n\n    ( \"smile\", 128522 )\n    |>mapRight Char.fromCode\n\n> `( \"smile\", '😊' )`\n\nThis is handy when using maps or folds etc.\n\n    namedEmojiCodes=\n      PairDict.empty\n      |>PairDict.insert ( \"pear\", 127824 )\n      |>PairDict.insert ( \"tree\", 127795 )\n    namedEmojis=\n      namedEmojiCodes\n      |>PairDict.map (Pair.map String.toUpper)\n\n> `PairDict.fromList [ ( \"PEAR\", '🍐' ), ( \"TREE\", '🌳' ) ]`\n","type":"(left -> resultLeft) -> (right -> resultRight) -> Pair.Pair left right -> Pair.Pair resultLeft resultRight"},{"name":"mapLeft","comment":" map the `left` value in a `Pair`\n\n    ( 128522, \"smile\" )\n    |>mapLeft Char.fromCode\n\n> `( '😊', \"smile\" )`\n\nThis is handy when using maps or folds etc.\n\n    namedEmojiCodes=\n      PairDict.empty\n      |>PairDict.insert ( 127824, \"pear\" )\n      |>PairDict.insert ( 127795, \"tree\" )\n    namedEmojis=\n      namedEmojiCodes\n      |>PairDict.map (Pair.mapLeft Char.fromCode)\n\n> `PairDict.fromList [ ( '🍐', \"pear\" ), ( '🌳', \"tree\" ) ]`\n","type":"(left -> resultLeft) -> Pair.Pair left right -> Pair.Pair resultLeft right"},{"name":"mapRight","comment":" map the `right` value in a `Pair`\n\n    ( \"smile\", 128522 )\n    |>mapRight Char.fromCode\n\n> `( \"smile\", '😊' )`\n\nThis is handy when using maps or folds etc.\n\n    namedEmojiCodes=\n      PairDict.empty\n      |>PairDict.insert ( \"pear\", 127824 )\n      |>PairDict.insert ( \"tree\", 127795 )\n    namedEmojis=\n      namedEmojiCodes\n      |>PairDict.map (Pair.mapRight Char.fromCode)\n\n> `PairDict.fromList [ ( \"pear\", '🍐' ), ( \"tree\", '🌳' ) ]`\n","type":"(right -> resultRight) -> Pair.Pair left right -> Pair.Pair left resultRight"},{"name":"rightIn","comment":" access the right value in a `Pair`.\n\n    openClosedCurlyBracePair=\n      ( '{', '}' )\n    closedCurly= rightIn openClosedCurlyBracePair\n","type":"Pair.Pair left right -> right"}],"binops":[]},{"name":"PairDict","comment":" \n@docs PairDict\n\n## create\n@docs empty, fromDict, fromList, decode\n\n## scan\n@docs rightOf, leftOf, equal, emptyOrMore, size\n\n## in\n@docs insert, union\n\n## out\n@docs removeLeft, removeRight\n\n## shape\n@docs lefts, rights, fold, map, toDict, encode\n","unions":[{"name":"PairDict","comment":" Want to look up value-pairs from the left or the right?\n\n> You want the left value of `🗝️ 1` and the right value of `🔑 0`?\n\n      → ( 🔑 0, 🗝️ 2 )\n        ( 🔑 2, 🗝️ 0 )\n        ( 🔑 1, 🗝️ 1 ) ←\n\n> Going through while checking, if your key is equal... Ah! Here they are:\n\n        🔑 1 and 🗝️ 2\n\nLike [assoc-list](https://github.com/pzp1997/assoc-list),\na `PairDict` allows for anything as left or right values except for functions and things that contain functions.\n\n## Example: cased letters\n    lowerUppercaseLetters=\n      PairDict.empty\n      |>PairDict.insert ( 'a', 'A' )\n      |>PairDict.insert ( 'b', 'B' )\n      |>PairDict.insert ( 'c', 'C' )\n\n    upperCase char=\n      rightOf char lowerUppercaseLetters\n","args":["left","right"],"cases":[]}],"aliases":[],"values":[{"name":"decode","comment":" A `Json.Decode.Decoder` for `PairDict`s, encoded by `encodePair`.\n\nThe order of insertion is not reconstructed (see `equal`)\n\n    \"\"\"\n    [\n     {\n      \\\"left\\\": 2,\n      \\\"right\\\": 22\n     },\n     {\n      \\\"left\\\": 1,\n      \\\"right\\\": 11\n     }\n    ]\n    \"\"\"\n    |>Decode.decodeString\n        (PairDict.decode\n          Decode.int Decode.int\n        )\n\n> `Ok (Pairs [ ( 1, 11 ), ( 2, 22 ) ])` = a `PairDict`\n","type":"Json.Decode.Decoder left -> Json.Decode.Decoder right -> Json.Decode.Decoder (PairDict.PairDict left right)"},{"name":"empty","comment":" A `PairDict` with no `Pair`s inside\n","type":"PairDict.PairDict left right"},{"name":"emptyOrMore","comment":" `ifEmpty` if the `PairDict` contains no `Pair`s,\nelse `ifMore` with the most recently inserted `Pair` followed by a `PairDict` with the other `Pair`s.\n\nIt has a very similar use case to a `case` .. `of` on a `List`.\n\n    isEmpty=\n      PairDict.emptyOrMore\n        { ifEmpty= True\n        , ifMore= \\_ _-> False\n        }\n    mostRecent=\n      PairDict.emptyOrMore\n        { ifMore= \\pair _-> Just pair\n        , ifEmpty= Nothing\n        }\n    removeMostRecent=\n      PairDict.emptyOrMore\n        { ifMore= \\_ rest-> rest\n        , ifEmpty= PairDict.empty\n        }\n","type":"{ ifEmpty : result, ifMore : Pair.Pair left right -> PairDict.PairDict left right -> result } -> PairDict.PairDict left right -> result"},{"name":"encode","comment":" Convert a `PairDict` to a `Json.Encode.Value`.\n\n    somePairDict=\n      PairDict.empty\n      |>PairDict.insert ( 1, 11 )\n      |>PairDict.insert ( 2, 22 )\n    Encode.encode 1\n      (PairDict.encode\n        Encode.int Encode.int\n        somePairDict\n      )\n\n\n    \"\"\"\n    [\n     {\n      \\\"left\\\": 2,\n      \\\"right\\\": 22\n     },\n     {\n      \\\"left\\\": 1,\n      \\\"right\\\": 11\n     }\n    ]\n    \"\"\"\n","type":"(left -> Json.Encode.Value) -> (right -> Json.Encode.Value) -> PairDict.PairDict left right -> Json.Encode.Value"},{"name":"equal","comment":" using (==) built-in equality is often not useful in the context of association-dicts.\n\nIgnoring insertion order: do these 2 `PairDict`s have the same size and identical `Pair`s?\n\n    letterCodes=\n      PairDict.fromList\n        [ ( 'a', 97 ), ( 'b', 98 ) ]\n    fancyCompetingLetterCodes=\n      PairDict.empty\n      |>PairDict.insert ( 'b', 98 )\n      |>PairDict.insert ( 'a', 97 )\n    \n    PairDict.equal\n      letterCodes\n      fancyCompetingLetterCodes\n> `True`\n","type":"PairDict.PairDict left right -> PairDict.PairDict left right -> Basics.Bool"},{"name":"fold","comment":" Reduce the left-right `Pair`s from most recently inserted\nto least recently inserted.\nA fold in the other direction doesn't exist, as association-`Dict`s should rarely rely on order (see `equal`)\n\n    brackets=\n      PairDict.empty\n      |>PairDict.insert ( '(', ')' )\n      |>PairDict.insert ( '{', '}' )\n\n    openingAndClosing=\n      brackets\n      |>PairDict.fold\n          (\\( left, right ) acc->\n            acc++[ String.fromList [ left, right ] ]\n          )\n          []\n> `[ \"{}\", \"()\" ]`\n","type":"(Pair.Pair left right -> acc -> acc) -> acc -> PairDict.PairDict left right -> acc"},{"name":"fromDict","comment":" Create a `PairDict` from a association-`Dict`. `left` is the key, `right` is the value.\nIf multiple equal keys or values are present, the value **first** in the `Dict` is **prefered**.\n    \n    lowerToUpperLetters=\n      AssocList.empty\n      |>AssocList.insert 'a' 'A'\n      |>AssocList.insert 'b' 'B'\n\n    lowerUpperLetters=\n      PairDict.fromDict lowerToUpperLetters\n","type":"AssocList.Dict left right -> PairDict.PairDict left right"},{"name":"fromList","comment":" Create a `PairDict` _conveniently_ from `Tuple`s. `left` is the first, `right` is the second.\nIf right or left values are given multiple times, the value **first** in the `List` is **prefered**.\n    \n    PairDict.fromList\n      [ ( 'b', 'B' ) --insert ( 'b', 'B' )\n      , ( 'a', 'A' ) --insert ( 'a', 'A' )\n      , ( 'b', 'C' ) --ignored, as the left value already exists\n      , ( 'c', 'A' ) --ignored, as the right value already exists\n      , ( 'c', 'C' ) --insert ( 'c', 'C' )\n      ]\n","type":"List.List (Pair.Pair left right) -> PairDict.PairDict left right"},{"name":"insert","comment":" Put in a left-right-`Pair`.\n\nIf either **value** is already **present**, the `PairDict` is **unchanged**.\n\n    empty\n    |>insert ( 'b', 'B' ) --puts it in \n    |>insert ( 'a', 'A' ) --puts it in\n    |>insert ( 'b', 'C' ) --ignored, the left value already exists\n    |>insert ( 'c', 'A' ) --ignored, the right value already exists\n    |>insert ( 'c', 'C' ) --puts it in\n","type":"Pair.Pair left right -> PairDict.PairDict left right -> PairDict.PairDict left right"},{"name":"leftOf","comment":" `Just` the right value if the left value is present in the `PairDict`, else `Nothing`\n\n    casedLetters=\n      PairDict.empty\n      |>PairDict.insert ( 'a', 'A' )\n      |>PairDict.insert ( 'b', 'B' )\n\n    upperCase char=\n      rightOf char casedLetters\n","type":"right -> PairDict.PairDict left right -> Maybe.Maybe left"},{"name":"lefts","comment":" Values on the left.\n\n    brackets=\n      PairDict.fromList\n        [ ( '(', ')' ), ( '{', '}' ) ]\n    opening= lefts brackets\n","type":"PairDict.PairDict left right -> List.List left"},{"name":"map","comment":" map pairs\n\n    digitNames=\n      PairDict.empty\n      |>PairDict.insert ( 0, \"zero\" )\n      |>PairDict.insert ( 1, \"one\" )\n\n    mathSymbolNames=\n      digitNames\n      |>PairDict.map (Pair.mapLeft String.fromInt)\n      |>PairDict.insert ( \"+\", \"plus\" )\n","type":"(Pair.Pair left right -> Pair.Pair resultLeft resultRight) -> PairDict.PairDict left right -> PairDict.PairDict resultLeft resultRight"},{"name":"removeLeft","comment":" remove left-right pair.\nIf **`left` does not exist**, the `PairDict` is **unchanged**\n\n    PairDict.empty\n    |>PairDict.insert \"(\" \")\"\n    |>PairDict.removeLeft \")\" \n        --unchanged, \")\" is not a left value\n    |>PairDict.removeLeft \"(\"\n        --removes ( \"(\", \")\" )\n> `PairDict.empty`\n","type":"left -> PairDict.PairDict left right -> PairDict.PairDict left right"},{"name":"removeRight","comment":" remove left-right pair.\nIf `right` does not exist, the `PairDict` is unchanged\n\n    PairDict.empty\n    |>PairDict.insert ( \"(\", \")\" )\n    |>PairDict.removeRight \"(\"\n        --unchanged, \"(\" is not a right value\n    |>PairDict.removeRight \")\"\n        --removes ( \"(\", \")\" )\n> `PairDict.empty`\n","type":"right -> PairDict.PairDict left right -> PairDict.PairDict left right"},{"name":"rightOf","comment":" `Just` the right value if the left value is present in the `PairDict`, else `Nothing`\n\n    casedLetters=\n      PairDict.empty\n      |>PairDict.insert ( 'a', 'A' )\n      |>PairDict.insert ( 'b', 'B' )\n\n    lowerCase char=\n      leftOf char casedLetters\n","type":"left -> PairDict.PairDict left right -> Maybe.Maybe right"},{"name":"rights","comment":" Values on the right.\n\n    brackets=\n      PairDict.fromList\n        [ ( '(', ')' ), ( '{', '}' ) ]\n    closing= rights brackets\n","type":"PairDict.PairDict left right -> List.List right"},{"name":"size","comment":" How many `Pair`s there are in a `PairDict`.\n\n    PairDict.size empty\n> `0`\n    \n    meaninglessNumbers=\n      PairDict.fromList\n        (List.range 0 41\n        |>List.map (\\i-> ( i, i ))\n        )\n    PairDict.size meaninglessNumbers\n> `42`\n","type":"PairDict.PairDict left right -> Basics.Int"},{"name":"toDict","comment":" Convert to an association-`Dict`, which you can access only from the left\n\n    casedLetters=\n      PairDict.fromList\n        [ ( 'A', 'a' ), ( 'B', 'b' ) ]\n    lowerFromUpper=\n      casedLetters |>dictFromLeft\n","type":"PairDict.PairDict left right -> AssocList.Dict left right"},{"name":"union","comment":" Merge 2 `PairDict`s.\nIf a value on the left or right is present, prefer the last `PairDict`.\n\n    numberNamedOperators=\n      PairDict.fromList\n        [ ( '+', \"plus\" )\n        , ( '-', \"minus\" )\n        ]\n    customNamedOperators=\n      PairDict.fromList\n        [ ( '∧', \"and\" )\n        , ( '∨', \"or\" )\n        , ( '-', \"negate\" )\n        ]\n    validNamedOperators=\n      PairDict.union\n        custumNamedOperators --has a '-' left\n        numberOperatorNames --preferred → its '-'-Pair is inserted\n","type":"PairDict.PairDict left right -> PairDict.PairDict left right -> PairDict.PairDict left right"}],"binops":[]}]