[{"name":"Char.Order","comment":" `Order` `Char`s\n\n\n## casing\n\n@docs Case\n\n\n### order\n\n@docs lowerUpper, LowerUpper, upperLower\n\n\n## [`Order`](Order#Ordering)\n\n@docs unicode, Unicode\n@docs aToZ, AToZ, AToZTag\n\n","unions":[{"name":"AToZTag","comment":" Wrapper tag for [`AToZ`](#AToZ)\n","args":[],"cases":[]},{"name":"Case","comment":" `Case` of a letter. [`Ordering`](Order#Ordering)s:\n\n  - [`lowerUpper`](#lowerUpper)\n  - [`upperLower`](#upperLower)\n  - [`Order.tie`](Order#tie)\n\n","args":[],"cases":[["CaseLower",[]],["CaseUpper",[]]]},{"name":"LowerUpper","comment":" Tag for [`lowerUpper`](#lowerUpper)\n","args":[],"cases":[]},{"name":"Unicode","comment":" Tag for [`unicode`](#unicode)\n","args":[],"cases":[]}],"aliases":[{"name":"AToZ","comment":" Tag for [`aToZ`](#aToZ)\n","args":["caseOrder"],"type":"( Char.Order.AToZTag, caseOrder )"}],"values":[{"name":"aToZ","comment":" `Order` `Char`s\n\n  - Both are letters → `Order` ascii-alphabetically (a < ... < z)\n      - They're the same letter? → a given [`Ordering`](Order#Ordering) on their [cases](#Case)\n  - Both aren't letters → `Order` [according to unicode char code](#unicode)\n  - Only one is a letter → the letter is considered greater\n\n```\nOrder.with (Char.Order.aToZ Char.Order.upperLower) 'b' 'D'\n--> LT\n\nOrder.with (Char.Order.aToZ Char.Order.upperLower) 'l' 'L'\n--> GT\n\nOrder.with (Char.Order.aToZ Char.Order.upperLower) 'i' '!'\n--> GT\n\nOrder.with (Char.Order.aToZ Char.Order.upperLower) '-' '!'\n--> Order.with Char.Order.unicode '-' '!'\n```\n\n","type":"Order.Ordering Char.Order.Case charOrderTag -> Order.Ordering Char.Char (Char.Order.AToZ charOrderTag)"},{"name":"lowerUpper","comment":" `'a' < 'A'`\n","type":"Order.Ordering Char.Order.Case Char.Order.LowerUpper"},{"name":"unicode","comment":" [`Ordering`](Order#Ordering) according to the unicode char code.\n\nThis behavior matches elm's `Basics.compare`.\n\n","type":"Order.Ordering Char.Char Char.Order.Unicode"},{"name":"upperLower","comment":" `'A' < 'a'`\n","type":"Order.Ordering Char.Order.Case (Order.Reverse Char.Order.LowerUpper)"}],"binops":[]},{"name":"Float.Order","comment":" `Order` `Float`s\n\n@docs up, Up, down\n\n","unions":[{"name":"Up","comment":" Tag for [`up`](#up)\n","args":[],"cases":[]}],"aliases":[],"values":[{"name":"down","comment":" `Order` `Float`s where higher means greater\n\n    import Order\n\n    Order.with Float.Order.down 2.1 40.34\n    --> GT\n\n","type":"Order.Ordering Basics.Float (Order.Reverse Float.Order.Up)"},{"name":"up","comment":" `Order` `Float`s where lower means greater\n\n    import Order\n\n    Order.with Float.Order.up 40.34 2.1\n    --> GT\n\n","type":"Order.Ordering Basics.Float Float.Order.Up"}],"binops":[]},{"name":"Int.Order","comment":" `Order` `Int`s\n\n@docs up, Up\n@docs down, Down\n\n","unions":[{"name":"Up","comment":" Tag for [`up`](#up)\n","args":[],"cases":[]}],"aliases":[{"name":"Down","comment":" Tag for [`down`](#down)\n","args":[],"type":"Order.Reverse Int.Order.Up"}],"values":[{"name":"down","comment":" `Order` `Int`s where higher means greater\n\n    import Order\n\n    Order.with Int.Order.down 2 40\n    --> GT\n\n","type":"Order.Ordering Basics.Int Int.Order.Down"},{"name":"up","comment":" `Order` `Int`s where lower means greater\n\n    import Order\n\n    Order.with Int.Order.up 40 2\n    --> GT\n\n","type":"Order.Ordering Basics.Int Int.Order.Up"}],"binops":[]},{"name":"Keys","comment":" Multiple key [`Ordering`](Order#Ordering)s\n\nConfigure what's considered a key inside a [`KeysSet`](KeysSet#KeysSet)\n\nCreate starting with [`Keys.for`](#for) and building with [`|> Keys.by`](#by) as shown in\nthe [readme examples](https://dark.elm.dmy.fr/packages/lue-bird/elm-keysset/)\n\nYou can just ignore the `Typed` thing but if you're curious → [`typed-value`](https://dark.elm.dmy.fr/packages/lue-bird/elm-typed-value/latest/)\n\n@docs Keys, KeysTag, Key\n\n\n## create\n\n@docs identity, Identity\n@docs for, KeysBeingBuilt\n@docs by\n\n\n# safe internals\n\nYou won't need them if you just want to use [`KeysSet`](KeysSet#KeysSet).\n... It's safe to expose this information, tho, so why not make it available :)\n\n\n## transform\n\n@docs toArray\n\n\n## single key\n\n@docs toKeyWith, keyOrderWith\n\n","unions":[],"aliases":[{"name":"Identity","comment":" Resulting type of [`Keys.identity`](#identity).\n\n    import Map\n    import Order\n    import Float.Order\n    import KeysSet\n    import Keys\n\n    floatUp : Keys.Identity Float Float.Order.Up\n    floatUp =\n        Keys.identity Float.Order.up\n\n    KeysSet.fromList floatUp [ -1.1, 5, 5, 8.7, 7.8 ]\n        |> KeysSet.toList ( floatUp, Basics.identity )\n    --> [ -1.1, 5, 7.8, 8.7 ]\n\n","args":["element","elementOrderTag"],"type":"Keys.Keys element (Keys.Key element (Order.By Map.Identity elementOrderTag) element N.N1) N.N1"},{"name":"Key","comment":" By which aspect = key and in which key `Order` elements should be sorted\n","args":["element","orderByTag","key","keyCount"],"type":"Keys.Internal.Key element orderByTag key keyCount"},{"name":"Keys","comment":" The type of fully constructed [`KeysBeingBuilt`](#KeysBeingBuilt)\nready to use.\n\n\"infer types\" is your friend here\n\n    import Keys exposing (Keys, Key)\n    import Order\n    import Char.Order\n    import String.Order\n    import Emptiable\n    import N exposing (N2)\n\n    userKeys :\n        -- just infer this\n        Keys\n            User\n            { name :\n                Key\n                    User\n                    (Order.By\n                        User.Name\n                        (String.Order.Earlier (Char.Order.AToZ Order.Tie))\n                    )\n                    String\n                    N2\n            , email : Key User (Order.By User.Email Email.DefaultOrder) String N2\n            }\n            N2\n    userKeys =\n        Keys.for (\\name email -> { name = name, email = email } )\n            |> Keys.by ( .name, User.name )\n                (String.Order.earlier (Char.Order.aToZ Order.tie))\n            |> Keys.by ( .email, User.email )\n                Email.defaultOrder\n\n    Emptiable.empty\n        |> KeysSet.insert userKeys\n            { username = \"ben\", email = ..ben10@gmx.de.. }\n        |> KeysSet.insert userKeys\n            { username = \"mai\", email = ..ben10@gmx.de.. }\n        -- not inserted\n        -- There's already an element where .email is ..ben10@gmx.de..\n\nWhat's with those `Up N.. To N..`?\n_Internally_, each key will be assigned an index.\nthat type from [bounded-nat](https://dark.elm.dmy.fr/packages/lue-bird/elm-bounded-nat/latest/)\npreserves the knowledge that each key's index is less than the whole count.\n\n","args":["element","keys","keyCount"],"type":"Keys.KeysBeingBuilt element keys keys (N.On keyCount)"},{"name":"KeysBeingBuilt","comment":" Once you supply all the necessary key-[`Ordering`](Order#Ordering)s with [`by`](#by),\na [`KeysBeingBuilt`](#KeysBeingBuilt) is automatically of type [`Keys`](#Keys).\n\nSo if you for example infer the type\n\n    KeysBeingBuilt element { yourKeys } { yourKeys } keyCount\n\nyou can replace it by\n\n    Keys element { yourKeys } keyCount\n\nIt's data is unaccessible because you shouldn't be able to\n\n  - retrieve it's keys to use in different [`Keys`](#Keys)\n  - have an out of sync [array](#toArray) representation\n\n","args":["element","keysComplete","keysConstructor","keyCount"],"type":"Keys.Internal.KeysBeingBuilt element keysComplete keysConstructor keyCount"},{"name":"KeysTag","comment":" Tags correctly constructed [`Keys`](#Keys) (and each [`Key`](#Key))\n","args":[],"type":"Keys.Internal.KeysTag"}],"values":[{"name":"by","comment":" Add a key\n\n  - what name does the key have? (same as in the initial record from [`Keys.for`](#for))\n  - which aspect should be sorted by? → [`Mapping`](Map#Mapping)\n  - how should we compare these aspects? [`Ordering`](Order#Ordering)\n\n","type":"( keysComplete -> Keys.Key element (Order.By toKeyTag keyOrderTag) key (N.Add1 keyCountFrom1), Map.Mapping element toKeyTag key ) -> Order.Ordering key keyOrderTag -> Keys.KeysBeingBuilt element keysComplete (Keys.Key element (Order.By toKeyTag keyOrderTag) key (N.Add1 keyCountFrom1) -> keysConstructedPartially) (N.Up (N.Add1 toKeyCountFrom1) N.To (N.Add1 keyCountFrom1)) -> Keys.KeysBeingBuilt element keysComplete keysConstructedPartially (N.Up toKeyCountFrom1 N.To (N.Add1 keyCountFrom1))"},{"name":"for","comment":" Start a [keys builder](#KeysBeingBuilt) by giving names to the individual keys as arguments\nusing a record\n\n    userKeys :\n        Keys\n            User\n            { email : Key User (Order.By User.Email Email.Order) Email N1 }\n            N1\n    userKeys =\n        Keys.for (\\email -> { email = email })\n            |> Keys.by ( .email, User.email, Email.order )\n\n    Emptiable.empty\n        |> KeysSet.insert userKeys\n            { name = \"ben\", email = \"ben10@gmx.de\" }\n        |> KeysSet.insert userKeys\n            { name = \"mai\", email = \"ben10@gmx.de\" }\n        -- not inserted\n        -- There's already an element where .email is \"ben10@gmx.de\"\n\n","type":"keysConstructor -> Keys.KeysBeingBuilt element_ completeKeys_ keysConstructor (N.Up0 keyCount_)"},{"name":"identity","comment":" Ordering by the element itself.\n\nShort for\n\n    Keys.identity order =\n        Keys.for identity |> Keys.by ( identity, Map.identity ) order\n\nin [`KeysSet`](KeysSet#KeysSet)\n\n    import Map\n    import Order\n    import Int.Order\n    import Keys\n    import KeysSet\n\n    intUp : Keys.Identity Int Int.Order.Up\n    intUp =\n        Keys.identity Int.Order.up\n\n    KeysSet.fromList intUp [ -1, 5, 5, 8, 7 ]\n        |> KeysSet.toList ( intUp, Basics.identity )\n    --> [ -1, 5, 7, 8 ]\n\n","type":"Order.Ordering element elementOrderTag -> Keys.Identity element elementOrderTag"},{"name":"keyOrderWith","comment":" How to order by the specified key\n","type":"( Keys.Keys element keys keyCount, keys -> Keys.Key element by_ key keyCount ) -> ( key, key ) -> Basics.Order"},{"name":"toArray","comment":" List all keys in the `keys` record as an [array](https://dark.elm.dmy.fr/packages/lue-bird/elm-typesafe-array/latest/)\nof functions\ndetermining the `Order` of 2 elements\n","type":"Keys.Keys element keys_ keyCount -> ArraySized.ArraySized (( element, element ) -> Basics.Order) (N.Exactly (N.On keyCount))"},{"name":"toKeyWith","comment":" How to turn the element into the specified key\n","type":"( Keys.Keys element keys keyCount, keys -> Keys.Key element by_ key keyCount ) -> element -> key"}],"binops":[]},{"name":"KeysSet","comment":" Lookup with multiple [`Keys`](Keys#Keys)\n\n@docs KeysSet\n\n  - [`element`](#element), [`end`](#end), [insert](#insertIfNoCollision) versions, [elementAlter](#elementAlterIfNoCollision) versions, [`remove`](#remove) are runtime `log n`\n  - [`size`](#size) is runtime `1`\n  - [`toList`](#toList), [`toStack`](#toStack), [`toKeys`](#toKeys), [`foldFrom`](#foldFrom), [`foldFromOne`](#foldFromOne), [`foldUntilCompleteFrom`](#foldUntilCompleteFrom), [`foldUntilCompleteFromOne`](#foldUntilCompleteFromOne) are runtime `n`\n\n\n## create\n\n[`Emptiable.empty`](https://dark.elm.dmy.fr/packages/lue-bird/elm-emptiness-typed/latest/Emptiable#empty),\n\n@docs one\n@docs fromStack, fromList\n\n\n## observe\n\n@docs size, element, end\n\n\n## alter\n\n@docs insertIfNoCollision, insertReplacingCollisions\n@docs remove\n@docs elementAlterIfNoCollision, elementAlterReplacingCollisions\n@docs map, fillsMap\n\n\n## combine\n\n@docs unifyWith, except, intersect\n@docs fold2From, fold2FromOne\n\n\n## transform\n\n@docs toKeys, toStack, toList\n@docs foldFrom, foldFromOne\n@docs foldUntilCompleteFrom, foldUntilCompleteFromOne\n\nThere are more fold variants that could be exposed if you have a need for them,\nnamely\n\n  - `fold...AnyOrder` which doesn't need a specific key and direction\n  - `foldNavigate` which can decide for each value whether to even fold up or down\n\nOpen an issue and I'll expose them :)\n\n","unions":[],"aliases":[{"name":"KeysSet","comment":" 🗃️ Non-empty AVL-tree-based look-up. Elements and keys can be of any type\n\n    import KeysSet exposing (KeysSet)\n    import Stack\n    import User exposing (User(..))\n\n    users : Emptiable (KeysSet User User.ByName N1) never_\n    users =\n        KeysSet.fromStack User.byName\n            (Stack.topBelow\n                (User { name = \"Alice\", age = 28, height = 1.65 })\n                [ User { name = \"Bob\", age = 19, height = 1.82 }\n                , User { name = \"Chuck\", age = 33, height = 1.75 }\n                ]\n            )\n\nwhere\n\n    -- module User exposing (ByName, User(..), byName)\n\n\n    import Char.Order\n    import Keys exposing (Key, Keys)\n    import KeysSet\n    import Map exposing (Mapping)\n    import N exposing (N1)\n    import Order\n    import String.Order\n\n    type User\n        = User { name : String, age : Int, height : Float }\n\n    type Name\n        = Name\n\n    name : Mapping User Name String\n    name =\n        Map.tag Data (\\(User userData) -> userData.name)\n\n    type alias ByName =\n        { name :\n            Key\n                User\n                (Order.By\n                    Name\n                    (String.Order.Earlier\n                        (Char.Order.AToZ Char.Order.LowerUpper)\n                    )\n                )\n                String\n                N1\n        }\n\n    byName : Keys User ByName N1\n    byName =\n        Keys.for (\\name_ -> { name = name_ })\n            |> Keys.by ( identity, Map.identity )\n                (String.Order.earlier\n                    (Char.Order.aToZ Char.Order.lowerUpper)\n                )\n\n","args":["element","keys","keyCount"],"type":"KeysSet.Internal.KeysSet element keys keyCount"}],"values":[{"name":"element","comment":" Access the element associated with a given key.\nIf no element with the given key is not present, `Emptiable.empty`\n\n    import Emptiable exposing (Emptiable, filled)\n    import Typed\n    import Stack\n    import N exposing (N1)\n    import Keys exposing (Keys, Key)\n    import KeysSet exposing (KeysSet)\n    import Map exposing (Mapping)\n    import Order\n    import Char.Order\n    import String.Order\n\n    type alias Animal =\n        { name : String\n        , kind : AnimalKind\n        }\n\n    type AnimalKind\n        = Mouse\n        | Cat\n\n    type alias ByName =\n        { name :\n            Key\n                Animal\n                (Order.By\n                    Name\n                    (String.Order.Earlier\n                        (Char.Order.AToZ Char.Order.LowerUpper)\n                    )\n                )\n                String\n                N1\n        }\n\n    animals : Emptiable (KeysSet Animal ByName N1) never_\n    animals =\n        KeysSet.fromStack animalByName\n            (Stack.topBelow\n                { name = \"Tom\", kind = Cat }\n                [ { name = \"Jerry\", kind = Mouse }\n                ]\n            )\n\n    type Name\n        = Name -- not exposed\n\n    name : Mapping Animal Name String\n    name =\n        Map.tag Name .name\n\n    animalByName : Keys Animal ByName N1\n    animalByName =\n        Keys.for (\\name_ -> { name = name_ })\n            |> Keys.by ( .name, name )\n                (String.Order.earlier\n                    (Char.Order.aToZ Char.Order.lowerUpper)\n                )\n\n    animals |> KeysSet.element ( animalByName, .name ) \"Tom\" |> Emptiable.map .kind\n    --> filled Cat\n\n    animals |> KeysSet.element ( animalByName, .name ) \"Jerry\" |> Emptiable.map .kind\n    --> filled Mouse\n\n    animals |> KeysSet.element ( animalByName, .name ) \"Spike\" |> Emptiable.map .kind\n    --> Emptiable.empty\n\n","type":"( Keys.Keys element keys keyCount, keys -> Keys.Key element by_ key keyCount ) -> key -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) possiblyOrNever_ -> Emptiable.Emptiable element Possibly.Possibly"},{"name":"elementAlterIfNoCollision","comment":" Change the element with a given key in a given way\nOnly actually alter the element if the result doesn't have existing elements with a matching key (collisions).\nTo replace collisions with the result instead → [`elementAlterReplacingCollisions`](#elementAlterReplacingCollisions)\n\n    import Character\n\n    KeysSet.fromList Character.keys\n        [ { id = 0, char = 'A' }, { id = 1, char = 'B' } ]\n        |> KeysSet.elementAlterIfNoCollision ( Character.keys, .id )\n            1\n            (\\c -> { c | char = 'C' })\n            -- gets changed\n        |> KeysSet.elementAlterIfNoCollision ( Character.keys, .id )\n            1\n            (\\c -> { c | id = 0 })\n            -- doesn't get changed\n        |> KeysSet.toList ( Character.keys, .id )\n        --> [ { id = 0, char = 'A' }, { id = 1, char = 'C' } ]\n\nIf you want to sometimes [`remove`](#remove)\nor [insert](#insertIfNoCollision) a new value on empty for example,\nfirst ask for the [`element`](#element) with the same key, then\nmatch the [`Emptiable`](https://dark.elm.dmy.fr/packages/lue-bird/elm-emptiness-typed/latest/Emptiable)\nand operate as you like\n\n","type":"( Keys.Keys element keys keyCount, keys -> Keys.Key element by_ key keyCount ) -> key -> (element -> element) -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) possiblyOrNever -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) possiblyOrNever"},{"name":"elementAlterReplacingCollisions","comment":" Change the element with a given key in a given way\nIf the result has existing elements with a matching key (collisions), replace them.\nTo not alter the element if there are collisions with the result instead → [`elementAlterIfNoCollision`](#elementAlterIfNoCollision)\n\n    import Character\n\n    KeysSet.fromList Character.keys\n        [ { id = 0, char = 'A' }, { id = 1, char = 'B' } ]\n        |> KeysSet.elementAlterIfNoCollision ( Character.keys, .id )\n            1\n            (\\c -> { c | char = 'C' })\n            -- gets changed\n        |> KeysSet.elementAlterIfNoCollision ( Character.keys, .id )\n            1\n            (\\c -> { c | id = 0 })\n            -- doesn't get changed\n        |> KeysSet.toList ( Character.keys, .id )\n        --> [ { id = 0, char = 'A' }, { id = 1, char = 'C' } ]\n\nIf you want to sometimes [`remove`](#remove)\nor [insert](#insertIfNoCollision) a new value on empty for example,\nfirst ask for the [`element`](#element) with the same key, then\nmatch the [`Emptiable`](https://dark.elm.dmy.fr/packages/lue-bird/elm-emptiness-typed/latest/Emptiable)\nand operate as you like\n\n","type":"( Keys.Keys element keys keyCount, keys -> Keys.Key element by_ key keyCount ) -> key -> (element -> element) -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) possiblyOrNever -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) possiblyOrNever"},{"name":"end","comment":" The element associated with the lowest key\n\n    import Linear exposing (Direction(..))\n    import Emptiable exposing (Emptiable)\n    import N exposing (N1)\n    import Stack\n    import KeysSet exposing (KeysSet)\n    import Map exposing (Mapping)\n    import Order\n    import Char.Order\n    import String.Order\n    import Keys exposing (Keys, Key)\n\n    users : Emptiable (KeysSet User ByName N1) never_\n    users =\n        KeysSet.fromStack userByName\n            (Stack.topBelow\n                { name = \"Bob\", age = 19, height = 1.80 }\n                [ { name = \"Alia\", age = 28, height = 1.69 }\n                , { name = \"Chucki\", age = 33, height = 1.75 }\n                ]\n            )\n\n    users |> KeysSet.end ( userByName, .name ) Down\n    --> { name = \"Alia\", age = 28, height = 1.69 }\n\n    users |> KeysSet.end ( userByName, .name ) Up\n    --> { name = \"Chucki\", age = 33, height = 1.75 }\n\n    type alias User =\n        { name : String\n        , age : Int\n        , height : Float\n        }\n\n    type alias ByName =\n        { name :\n            Key\n                User\n                (Order.By\n                    Name\n                    (String.Order.Earlier\n                        (Char.Order.AToZ Char.Order.LowerUpper)\n                    )\n                )\n                String\n                N1\n        }\n\n    type Name\n        = Name -- not exposed\n\n    name : Mapping User Name String\n    name =\n        Map.tag Name .name\n\n    userByName : Keys User ByName N1\n    userByName =\n        Keys.for (\\name_ -> { name = name_ })\n            |> Keys.by ( .name, name )\n                (String.Order.earlier\n                    (Char.Order.aToZ Char.Order.lowerUpper)\n                )\n\nNotice how we safely avoided returning a `Maybe`\nthrough the use of [`Emptiable ... Never`](https://dark.elm.dmy.fr/packages/lue-bird/elm-emptiness-typed/latest/Emptiable)\n\nIf you don't know whether the [`KeysSet`](#KeysSet) will be empty\n\n    users\n        |> Emptiable.map (filled >> KeysSet.end ( userByName, .name ) Down)\n    --: Emptiable element Possibly\n\n","type":"( Keys.Keys element keys keyCount, keys -> Keys.Key element key_ by_ keyCount ) -> Linear.Direction -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) Basics.Never -> element"},{"name":"except","comment":" Keep only those elements whose keys don't appear in the given [`KeysSet`](#KeysSet)\n\n    import Character\n\n    KeysSet.fromList Character.keys\n        [ { id = 0, char = 'A' }\n        , { id = 1, char = 'B' }\n        , { id = 2, char = 'c' }\n        , { id = 3, char = 'd' }\n        ]\n        |> KeysSet.except ( Character.keys, .id )\n            (KeysSet.fromList Character.keys\n                [ { id = 2, char = 'c' }\n                , { id = 3, char = 'd' }\n                , { id = 4, char = 'e' }\n                , { id = 5, char = 'f' }\n                ]\n                |> KeysSet.toKeys ( Character.keys, .id )\n            )\n        |> KeysSet.toList ( Character.keys, .id )\n    --> [ { id = 0, char = 'A' }\n    --> , { id = 1, char = 'B' }\n    --> ]\n\n","type":"( Keys.Keys element keys keyCount, keys -> Keys.Key element by_ key keyCount ) -> Emptiable.Emptiable (KeysSet.KeysSet key incomingKeys_ incomingKeyCount_) incomingPossiblyOrNever_ -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) possiblyOrNever_ -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) Possibly.Possibly"},{"name":"fillsMap","comment":" Try to change each element based on its current value.\nOften, this is called \"filterMap\"\n\nRuntime `n * log n` just like [`KeysSet.map`](#map) because mapped keys could be different\n\nIf the keys of the mapped elements collide,\nthere's no promise of which element will be in the final mapped [`KeysSet`](#KeysSet)\n\n    {-| Keep only elements that pass a given test.\n    Often called \"filter\"\n    -}\n    when orderKey isGood =\n        KeysSet.fillsMap\n            (\\element ->\n                if element |> isGood then\n                    Just element\n\n                else\n                    Nothing\n            )\n            orderKey\n\n","type":"(element -> Emptiable.Emptiable mappedElement mappedElementPossiblyOrNever_) -> Keys.Keys mappedElement mappedKeys mappedKeyCount -> Emptiable.Emptiable (KeysSet.KeysSet element keys_ lastIndex_) possiblyOrNever_ -> Emptiable.Emptiable (KeysSet.KeysSet mappedElement mappedKeys mappedKeyCount) Possibly.Possibly"},{"name":"fold2From","comment":" Most powerful way of combining 2 [`KeysSet`](#KeysSet)s\n\nTraverses all the keys from both [`KeysSet`](#KeysSet)s _from lowest to highest_,\naccumulating whatever you want\nfor when a key appears in the\nfirst [`AndOr`](https://dark.elm.dmy.fr/packages/lue-bird/elm-and-or/latest/AndOr)\nsecond [`KeysSet`](#KeysSet).\n\nYou will find this as \"merge\" in most other dictionaries/sets,\nexcept that you have the [diff as a value](https://dark.elm.dmy.fr/packages/lue-bird/elm-and-or/latest/AndOr)\nyou can reduce with instead of separate functions for \"only first\", \"only second\" and \"both\".\n\nTo handle the [`AndOr`](https://dark.elm.dmy.fr/packages/lue-bird/elm-and-or/latest/AndOr)\ncases, use a `case..of` or the [helpers in `elm-and-or`](https://dark.elm.dmy.fr/packages/lue-bird/elm-and-or/latest/AndOr)\n\n","type":"folded -> (AndOr.AndOr firstElement secondElement -> folded -> folded) -> And.And { key : ( Keys.Keys firstElement firstKeys firstKeyCount, firstKeys -> Keys.Key firstElement firstBy_ key firstKeyCount ), set : Emptiable.Emptiable (KeysSet.KeysSet firstElement firstKeys firstKeyCount) firstPossiblyOrNever_ } { key : ( Keys.Keys secondElement secondKeys secondKeyCount, secondKeys -> Keys.Key secondElement secondBy_ key secondKeyCount ), set : Emptiable.Emptiable (KeysSet.KeysSet secondElement secondKeys secondKeyCount) secondPossiblyOrNever_ } -> folded"},{"name":"fold2FromOne","comment":" Most powerful way of combining 2 [`KeysSet`](#KeysSet)s\n\nTraverses all the keys from both [`KeysSet`](#KeysSet)s _from lowest to highest_,\naccumulating whatever you want\nfor when a key appears in the\nfirst [`AndOr`](https://dark.elm.dmy.fr/packages/lue-bird/elm-and-or/latest/AndOr)\nsecond [`KeysSet`](#KeysSet).\n\nYou will find this as \"merge\" in most other dictionaries/sets,\nexcept that you have the [diff as a value](https://dark.elm.dmy.fr/packages/lue-bird/elm-and-or/latest/AndOr)\nyou can reduce with instead of separate functions for \"only first\", \"only second\" and \"both\".\n\nTo handle the [`AndOr`](https://dark.elm.dmy.fr/packages/lue-bird/elm-and-or/latest/AndOr)\ncases, use a `case..of` or the [helpers in `elm-and-or`](https://dark.elm.dmy.fr/packages/lue-bird/elm-and-or/latest/AndOr)\n\n","type":"(AndOr.AndOr firstElement secondElement -> folded) -> (AndOr.AndOr firstElement secondElement -> folded -> folded) -> And.And { key : ( Keys.Keys firstElement firstKeys firstKeyCountFrom1, firstKeys -> Keys.Key firstElement firstBy_ key firstKeyCountFrom1 ), set : Emptiable.Emptiable (KeysSet.KeysSet firstElement firstKeys firstKeyCountFrom1) Basics.Never } { key : ( Keys.Keys secondElement secondKeys secondKeyCount, secondKeys -> Keys.Key secondElement secondBy_ key secondKeyCount ), set : Emptiable.Emptiable (KeysSet.KeysSet secondElement secondKeys secondKeyCount) secondPossiblyOrNever_ } -> folded"},{"name":"foldFrom","comment":" Fold over its elements from an initial accumulator value\nin a given [`Direction`](https://dark.elm.dmy.fr/packages/lue-bird/elm-linear-direction/latest/Linear#Direction)\n\n    import Linear exposing (Direction(..))\n    import Stack\n    import Int.Order\n    import KeysSet\n    import Keys\n\n    KeysSet.fromStack intUp\n        (Stack.topBelow 234 [ 345, 543 ])\n        |> KeysSet.foldFrom ( intUp, identity ) [] Down (::)\n    --> [ 234, 345, 543]\n\n    KeysSet.fromStack intUp\n        (Stack.topBelow 5 [ 7, -6 ])\n        |> KeysSet.foldFrom ( intUp, identity ) 0 Up (+)\n    --> 6\n\n    intUp : Keys.Identity Int Int.Order.Up\n    intUp =\n        Keys.identity Int.Order.up\n\n","type":"( Keys.Keys element keys keyCount, keys -> Keys.Key element key_ by_ keyCount ) -> folded -> Linear.Direction -> (element -> folded -> folded) -> Emptiable.Emptiable (KeysSet.KeysSet element keys_ keyCount) possiblyOrNever_ -> folded"},{"name":"foldFromOne","comment":" Fold, starting from one end element transformed to the initial accumulation value,\nthen reducing what's accumulated\nin a given [`Direction`](https://dark.elm.dmy.fr/packages/lue-bird/elm-linear-direction/latest/Linear#Direction)\n\n    import Linear exposing (Direction(..))\n    import Stack\n    import Int.Order\n    import Keys\n    import KeysSet\n\n    KeysSet.fromStack intUp\n        (Stack.topBelow 234 [ 345, 543 ])\n        |> KeysSet.foldFromOne ( intUp, identity )\n            Stack.one\n            Up\n            Stack.onTopLay\n    --> Stack.topBelow 543 [ 345, 234 ]\n\n    intUp : Keys.Identity Int Int.Order.Up\n    intUp =\n        Keys.identity Int.Order.up\n\n","type":"( Keys.Keys element keys keyCount, keys -> Keys.Key element key_ by_ keyCount ) -> (element -> folded) -> Linear.Direction -> (element -> folded -> folded) -> Emptiable.Emptiable (KeysSet.KeysSet element keys_ keyCount) Basics.Never -> folded"},{"name":"foldUntilCompleteFrom","comment":" [`foldFrom`](#foldFrom) with the ability to stop early once\na given reduce function returns a [`Complete`](https://dark.elm.dmy.fr/packages/lue-bird/elm-partial-or-complete/latest/PartialOrComplete#PartialOrComplete) value.\n\n    import Linear exposing (Direction(..))\n    import Stack\n    import Int.Order\n    import KeysSet\n    import Keys\n    -- from lue-bird/partial-or-complete\n    import PartialOrComplete exposing (PartialOrComplete(..))\n\n    KeysSet.fromList intUp [ 11, 21, 31, 41, 51 ]\n        -- do we have a sum >= 100?\n        |> KeysSet.foldUntilCompleteFrom ( intUp, identity )\n            0\n            Up\n            (\\n sumSoFar ->\n                if sumSoFar >= 100 then\n                    -- no need to sum the rest!\n                    () |> Complete\n                else\n                    sumSoFar + n |> Partial\n            )\n        |> PartialOrComplete.isComplete\n    --> True\n\n\n    intUp : Keys.Identity Int Int.Order.Up\n    intUp =\n        Keys.identity Int.Order.up\n\n","type":"( Keys.Keys element keys keyCount, keys -> Keys.Key element key_ by_ keyCount ) -> folded -> Linear.Direction -> (element -> folded -> PartialOrComplete.PartialOrComplete folded complete) -> Emptiable.Emptiable (KeysSet.KeysSet element keys_ keyCount) possiblyOrNever_ -> PartialOrComplete.PartialOrComplete folded complete"},{"name":"foldUntilCompleteFromOne","comment":" [`foldFromOne`](#foldFromOne) with the ability to stop early once\na given reduce function returns a [`Complete`](https://dark.elm.dmy.fr/packages/lue-bird/elm-partial-or-complete/latest/PartialOrComplete#PartialOrComplete) value.\n\n    import Linear exposing (Direction(..))\n    import Stack\n    import Int.Order\n    import KeysSet\n    import Keys\n    -- from lue-bird/partial-or-complete\n    import PartialOrComplete exposing (PartialOrComplete(..))\n\n    KeysSet.fromStack intUp\n        (Stack.topBelow 11 [ 21, 31, 41, 51 ])\n        -- take the last 3\n        |> KeysSet.foldUntilCompleteFromOne ( intUp, identity )\n            (\\lastElement ->\n                { stack = lastElement |> Stack.one\n                , length = 1\n                }\n                    |> Partial\n            )\n            Down\n            (\\element soFar ->\n                if soFar.length >= 3 then\n                    soFar.stack |> Complete\n                else\n                    { stack = soFar.stack |> Stack.onTopLay element\n                    , length = soFar.length + 1\n                    }\n                        |> Partial\n            )\n        -- if we have less than 3 elements, that's fine, too\n        |> PartialOrComplete.completeElseOnPartial .stack\n    --> Stack.topBelow 31 [ 41, 51 ]\n\n\n    intUp : Keys.Identity Int Int.Order.Up\n    intUp =\n        Keys.identity Int.Order.up\n\n","type":"( Keys.Keys element keys keyCount, keys -> Keys.Key element key_ by_ keyCount ) -> (element -> PartialOrComplete.PartialOrComplete folded complete) -> Linear.Direction -> (element -> folded -> PartialOrComplete.PartialOrComplete folded complete) -> Emptiable.Emptiable (KeysSet.KeysSet element keys_ keyCount) Basics.Never -> PartialOrComplete.PartialOrComplete folded complete"},{"name":"fromList","comment":" Convert to a [`KeysSet`](#KeysSet),\n⚠️ ignoring elements whose keys already exist **earlier** in the `List`\n\n    KeysSet.fromList User.byHandle\n        [ -- ↓ won't be part of the KeysSet\n          { handle = \"cr\", shown = \"chris \\\\o/\" }\n        , { handle = \"ann\", shown = \"Ann in stand by\" }\n        , -- ↓ will be part of the KeysSet\n          { handle = \"cr\", shown = \"creeper\" }\n        ]\n\nFor construction, use [`fromStack`](#fromStack) instead,\nproving to the compiler what you already know about its (non-)emptiness\n\n","type":"Keys.Keys element keys keyCount -> List.List element -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) Possibly.Possibly"},{"name":"fromStack","comment":" Convert to a [`KeysSet`](#KeysSet),\n⚠️ ignoring elements whose keys already exist **earlier** in the [`Stack`](https://dark.elm.dmy.fr/packages/lue-bird/elm-emptiness-typed/latest/Stack)\n\n    KeysSet.fromStack User.byHandle\n        (Stack.topBelow\n            -- ↓ won't be part of the KeysSet\n            { handle = \"cr\", shown = \"chris \\\\o/\" }\n            [ { handle = \"ann\", shown = \"Ann in stand by\" }\n            , -- ↓ will be part of the KeysSet\n              { handle = \"cr\", shown = \"creeper\" }\n            ]\n        )\n\n","type":"Keys.Keys element keys keyCount -> Emptiable.Emptiable (Stack.Stacked element) possiblyOrNever -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) possiblyOrNever"},{"name":"insertIfNoCollision","comment":" Insert a given element.\nIf the element you wanted to insert already has elements with a matching key (collisions),\nkeep the existing collision elements instead.\nTo replace collisions instead → [`insertReplacingCollisions`](#insertReplacingCollisions)\n\n    import BracketPair\n    import Emptiable\n\n    Emptiable.empty\n        |> KeysSet.insertIfNoCollision BracketPair.keys\n            { open = 'b', closed = 'C' }\n        |> KeysSet.insertIfNoCollision BracketPair.keys\n            { open = 'c', closed = 'A' }\n        |> KeysSet.insertIfNoCollision BracketPair.keys\n            { open = 'c', closed = 'C' }\n        |> KeysSet.toList ( BracketPair.keys, .open )\n    --> [ { open = 'b', closed = 'C' }, { open = 'c', closed = 'A' } ]\n\n","type":"Keys.Keys element keys keyCount -> element -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) possiblyOrNever_ -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) never_"},{"name":"insertReplacingCollisions","comment":" Insert a given element.\nIf the element you wanted to insert already has elements with a matching key (collisions),\nreplace all collisions.\nTo keep collisions instead → [`insertIfNoCollision`](#insertIfNoCollision)\n\n    import BracketPair\n    import Emptiable\n\n    Emptiable.empty\n        |> KeysSet.insertReplacingCollisions BracketPair.keys\n            { open = 'b', closed = 'C' }\n        |> KeysSet.insertReplacingCollisions BracketPair.keys\n            { open = 'c', closed = 'A' }\n        |> KeysSet.insertReplacingCollisions BracketPair.keys\n            { open = 'c', closed = 'C' }\n        |> KeysSet.toList ( BracketPair.keys, .open )\n    --> [ { open = 'c', closed = 'C' } ]\n\n","type":"Keys.Keys element keys keyCount -> element -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) possiblyOrNever_ -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) never_"},{"name":"intersect","comment":" Keep each element whose key also appears in a given [`KeysSet`](#KeysSet)\n","type":"( Keys.Keys element keys keyCount, keys -> Keys.Key element key_ by_ keyCount ) -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) incomingPossiblyOrNever_ -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) possiblyOrNever_ -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) Possibly.Possibly"},{"name":"map","comment":" Change each element based on its current value.\n\nRuntime `n * log n` because mapped keys could be different (many other dicts/sets have runtime `n`)\n\nIf the keys of the mapped elements collide,\nthere's no promise of which element will be in the final mapped [`KeysSet`](#KeysSet)\n\n","type":"(element -> mappedElement) -> Keys.Keys mappedElement mappedKeys mappedKeyCount -> Emptiable.Emptiable (KeysSet.KeysSet element keys_ (N.Add1 keyCountFrom1_)) possiblyOrNever -> Emptiable.Emptiable (KeysSet.KeysSet mappedElement mappedKeys mappedKeyCount) possiblyOrNever"},{"name":"one","comment":" [`KeysSet`](#KeysSet) containing a single given element.\n\nYou don't need to provide [`Keys`](Keys#Keys)\n\n","type":"element -> Emptiable.Emptiable (KeysSet.KeysSet element keys_ keyCount_) never_"},{"name":"remove","comment":" Remove its element whose key matches the given one.\nIf the key is not found, no changes are made\n\n    import Character\n\n    KeysSet.fromList Character.keys\n        [ { id = 0, char = 'A' }\n        , { id = 1, char = 'B' }\n        ]\n        |> KeysSet.insertIfNoCollision Character.keys\n            { id = 2, char = 'C' }\n        |> KeysSet.remove ( Character.keys, .id ) 2\n        |> KeysSet.toList ( Character.keys, .id )\n    --> [ { id = 0, char = 'A' }\n    --> , { id = 1, char = 'B' }\n    --> ]\n\n","type":"( Keys.Keys element keys keyCount, keys -> Keys.Key element by_ key keyCount ) -> key -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) possiblyOrNever_ -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) Possibly.Possibly"},{"name":"size","comment":" Number of elements in the [`KeysSet`](#KeysSet).\nRuntime `1`\n\n    KeysSet.one { name = \"Helium\", symbol = \"He\", atomicNumber = 2 }\n        |> KeysSet.size\n    --> 1\n\n","type":"Emptiable.Emptiable (KeysSet.KeysSet element_ keys_ keyCount_) possiblyOrNever_ -> Basics.Int"},{"name":"toKeys","comment":" A [`KeysSet`](#KeysSet) sorted by the identity of one of the keys of the original set.\nRuntime is O(n).\n","type":"( Keys.Keys element keys keyCount, keys -> Keys.Key element (Order.By toKeyTag_ keyOrderTag) key keyCount ) -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) possiblyOrNever -> Emptiable.Emptiable (KeysSet.KeysSet key (Keys.Identity key keyOrderTag) N.N1) possiblyOrNever"},{"name":"toList","comment":" Convert to a `List`\n\n    import Stack\n    import Keys exposing (Keys, Key)\n    import KeysSet\n    import Char.Order\n    import String.Order\n\n    nameAlphabetical : Keys.Identity String (String.Order.Earlier (Char.Order.AToZ Char.Order.LowerUpper))\n    nameAlphabetical =\n        Keys.identity\n            (String.Order.earlier\n                (Char.Order.aToZ Char.Order.lowerUpper)\n            )\n\n    KeysSet.fromStack nameAlphabetical\n        (Stack.topBelow \"Bob\" [ \"Alice\" ])\n        |> KeysSet.toList ( nameAlphabetical, identity )\n    --> [ \"Alice\", \"Bob\" ]\n\n    KeysSet.fromStack nameAlphabetical\n        (Stack.topBelow \"Bob\" [ \"Alice\" ])\n        |> KeysSet.toList ( nameAlphabetical, identity )\n        |> List.reverse\n    --> [ \"Bob\", \"Alice\" ]\n\nto carry over information about (non-)emptiness → [`toStack`](#toStack)\n\nUsing `==` on [`KeysSet`](#KeysSet)s will be slower than [`toList`](#toList) if you have more than 2 keys.\n\n","type":"( Keys.Keys element keys keyCount, keys -> Keys.Key element key_ by_ keyCount ) -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) possiblyOrNever_ -> List.List element"},{"name":"toStack","comment":" Convert to a `List` sorted by a given key\n\n    import Stack\n    import Order\n    import Char.Order\n    import String.Order\n    import Keys exposing (Keys, Key)\n    import KeysSet\n\n    nameAlphabetical : Keys.Identity String (String.Order.Earlier (Char.Order.AToZ Char.Order.LowerUpper))\n    nameAlphabetical =\n        Keys.identity\n            (String.Order.earlier\n                (Char.Order.aToZ Char.Order.lowerUpper)\n            )\n\n    KeysSet.fromStack nameAlphabetical\n        (Stack.topBelow \"Bob\" [ \"Alice\" ])\n        |> KeysSet.toStack ( nameAlphabetical, identity )\n    --> Stack.topBelow \"Alice\" [ \"Bob\" ]\n\n    KeysSet.fromStack nameAlphabetical\n        (Stack.topBelow \"Bob\" [ \"Alice\", \"Christoph\" ])\n        |> KeysSet.toStack ( nameAlphabetical, identity )\n        |> Stack.reverse\n    --> Stack.topBelow \"Christoph\" [ \"Bob\", \"Alice\" ]\n\nThe cool thing is that information about (non-)emptiness is carried over to the stack\n\nUse this to fold over its elements\n\n    import Stack\n    import Int.Order\n    import Keys exposing (Keys, Key)\n    import KeysSet\n    import Linear exposing (Direction(..))\n\n    intUp : Keys.Identity Int Int.Order.Up\n    intUp =\n        Keys.identity Int.Order.up\n\n    KeysSet.fromStack intUp\n        (Stack.topBelow 345 [ 234, 543 ])\n        |> KeysSet.toStack ( intUp, identity )\n    --> Stack.topBelow 234 [ 345, 543 ]\n    --  the type knows it's never empty\n\n    KeysSet.fromStack intUp\n        (Stack.topBelow 1 [ 2, 8, 16 ])\n        |> KeysSet.toStack ( intUp, identity )\n        |> Stack.fold Down (\\n soFar -> soFar - n)\n    --> 5\n\n","type":"( Keys.Keys element keys keyCount, keys -> Keys.Key element key_ by_ keyCount ) -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) possiblyOrNever -> Emptiable.Emptiable (Stack.Stacked element) possiblyOrNever"},{"name":"unifyWith","comment":" Combine with another [`KeysSet`](#KeysSet).\nOn key collision, keep the current [`KeysSet`](#KeysSet)'s element.\n\n(To instead replace current elements with incoming elements, swap the arguments)\n\n","type":"Keys.Keys element keys keyCount -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) incomingPossiblyOrNever_ -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) possiblyOrNever -> Emptiable.Emptiable (KeysSet.KeysSet element keys keyCount) possiblyOrNever"}],"binops":[]},{"name":"List.Order","comment":" `List` [`Ordering`](Order#Ordering)\n\n@docs earlier, Earlier, EarlierTag\n\n","unions":[{"name":"EarlierTag","comment":" Wrapper tag for [`Earlier`](#Earlier)\n","args":[],"cases":[]}],"aliases":[{"name":"Earlier","comment":" Tag for [`earlier`](#earlier)\n","args":["elementOrder"],"type":"( List.Order.EarlierTag, elementOrder )"}],"values":[{"name":"earlier","comment":" Order `List`s by elements first to last\n\n    import Order\n    import Int.Order\n    import List.Order\n\n    Order.with (List.Order.earlier Int.Order.up)\n        [ 11, 22, 33, 188 ]\n        [ 11, 22, 34 ]\n    --> LT\n\n","type":"Order.Ordering element elementTag -> Order.Ordering (List.List element) (List.Order.Earlier elementTag)"}],"binops":[]},{"name":"Map","comment":" Map content inside a nested structure\n\n@docs Mapping, Altering\n\n\n## create\n\n@docs tag\n@docs identity, Identity\n\n\n## combine\n\n@docs over, Over, OverTag\n\n\n## transform\n\n@docs with\n\n","unions":[{"name":"Identity","comment":" Opaque tag for [`identity`](#identity)\n","args":[],"cases":[]},{"name":"OverTag","comment":" Wrapper tag in [`Over`](#Over)\n","args":[],"cases":[]}],"aliases":[{"name":"Altering","comment":" [`Mapping`](#Mapping) that will preserve the element type.\n\n[`Altering`](#Altering) can be used to simplify argument and result types\n\n    -- module User.Map exposing (onHead)\n\n    import Map\n\n    type alias User =\n        { name : String, ... }\n\n    type Name\n        = Name\n\n    name : Altering String nameAlterTag -> Altering User ( Name, nameAlterTag )\n    name =\n        Typed.mapToWrap Name (\\f user -> { user | name = user.name |> f })\n\nThis applies to records, `type`s without any type variables or mapping some of many equal-typed elements\n\n","args":["subject","alterTag"],"type":"Map.Mapping subject alterTag subject"},{"name":"Mapping","comment":" [`Typed`](https://dark.elm.dmy.fr/packages/lue-bird/elm-typed-value/latest/) change\n\nTo create, combine\n\n  - a tag that uniquely describes the part\n  - a function that changes the `unmapped` to `mapped`\n\n```\n-- module Game exposing (Score, score)\n\ntype alias Game =\n    { ..., score : Int }\n\ntype Score\n    = Score\n\nscore : Mapping Game Score Int\nscore =\n    Map.tag Score .score\n```\n\nTo \"nest\" [`Mapping`](#Mapping)s\n[`typed-value`](https://dark.elm.dmy.fr/packages/lue-bird/elm-typed-value/latest/)\nhas some powerful helpers:\n\n    -- module String.Map exposing (each, Each, ToList, toList)\n    type ToList\n        = ToList\n\n    toList : Mapping String ToList (List Char)\n    toList =\n        Map.tag ToList String.toList\n\n    type Each\n        = Each\n\n    each :\n        Mapping element elementMapTag elementMapped\n        -> Mapping (List element) ( Each, elementMapTag ) (List elementMapped)\n    each elementMapping =\n        Typed.mapToWrap Each List.map elementMapping\n\nThere's nothing more to it\n\nUse [`Alter`] if `unmapped` and `mapped` types are the same\n\n","args":["unmapped","mapTag","mapped"],"type":"Typed.Typed Typed.Checked mapTag Typed.Public (unmapped -> mapped)"},{"name":"Over","comment":" Tag for [`over`](#over)\n","args":["mapTag","nextMapTag"],"type":"( Map.OverTag, ( mapTag, nextMapTag ) )"}],"values":[{"name":"identity","comment":" Returns what comes in without changing anything\n\n    \"please edit\"\n        |> Map.with Map.identity\n    --> \"please edit\"\n\n","type":"Map.Altering subject_ Map.Identity"},{"name":"over","comment":" Transform elements\nas shown in a given [`Mapping`](#Mapping) with a given function\n\n    import Typed\n\n    type Book\n        = Book\n\n    book : Mapping { book : { sales : Int } } Book { sales : Int }\n    book =\n        Typed.tag Book .book\n\n    type Sales\n        = Sales\n\n    sales : Mapping { sales : Int } Sales Int\n    sales =\n        Typed.tag Sales .sales\n\n    { book = { sales = 0 } }\n        |> Map.with (book |> Map.over sales)\n    --> 0\n\n","type":"Map.Mapping mapped nextMapTag nextMapped -> Map.Mapping unmapped structureTag mapped -> Map.Mapping unmapped (Map.Over structureTag nextMapTag) nextMapped"},{"name":"tag","comment":" Create a uniquely tagged [`Mapping`](#Mapping) for a given function `a -> b`.\n","type":"tag -> (a -> b) -> Map.Mapping a tag b"},{"name":"with","comment":" Apply the given change\n\n    import Typed\n\n    [ 'h', 'i' ]\n        |> Map.with (Typed.tag { whatever = () } String.fromList)\n    --> \"hi\"\n\n","type":"Map.Mapping unmapped mapTag_ mapped -> unmapped -> mapped"}],"binops":[]},{"name":"Order","comment":" Comparing things\n\nBuild tagged `compare` functions for basic types, records, `type` choices.\nAll without `comparable`, `number`, ...\n\n    import Order exposing (Ordering)\n    import Int.Order\n    import Char.Order\n    import String.Order\n    import Map exposing (Mapping)\n\n    type FirstName\n        -- no exposing (..)\n        = FirstName\n\n    firstName : Mapping User FirstName String\n    firstName =\n        Typed.tag FirstName (\\(User user) -> user.firstName)\n\n    type LastName\n        -- no exposing (..)\n        = LastName\n\n    lastName : Mapping User LastName String\n    lastName =\n        Typed.tag LastName (\\(User user) -> user.lastName)\n\n    type Age\n        -- no exposing (..)\n        = Age\n\n    age : Mapping User Age String\n    age =\n        Typed.tag Age (\\(User user) -> user.age)\n\n    type User\n        = User\n            { firstName : String\n            , lastName : String\n            , age : Int\n            }\n\n    type alias NameOrder =\n        String.Order.Earlier\n            (Char.Order.AToZ Char.Order.LowerUpper)\n\n    type alias Order =\n        Order.NextOnTie\n            (Order.By LastName NameOrder)\n            (Order.NextOnTie\n                (Order.By FirstName NameOrder)\n                (Order.By Age Order.Int.Up)\n            )\n\n    order : Ordering User Order\n    order =\n        Order.by lastName\n            (String.Order.earlier\n                (Char.Order.aToZ Char.Order.lowerUpper)\n            )\n            |> Order.onTie\n                (Order.by .firstName\n                    (String.Order.earlier\n                        (Char.Order.aToZ Char.Order.lowerUpper)\n                    )\n                )\n            |> Order.onTie\n                (Order.by .age Int.Order.up)\n\n    [ User { firstName = \"Andy\", lastName = \"Baldwin\", age = 90 }\n    , User { firstName = \"Bert\", lastName = \"Anderson\", age = 23 }\n    , User { firstName = \"Alec\", lastName = \"Anderson\", age = 8 }\n    , User { firstName = \"Alec\", lastName = \"Anderson\", age = 100 }\n    ]\n        |> List.sortWith (Order.with userOrder)\n    --> [ { firstName = \"Alec\", lastName = \"Anderson\", age = 8 }\n    --> , { firstName = \"Alec\", lastName = \"Anderson\", age = 100 }\n    --> , { firstName = \"Bert\", lastName = \"Anderson\", age = 23 }\n    --> , { firstName = \"Andy\", lastName = \"Baldwin\", age = 90 }\n    --> ]\n\n[↑ another example](https://github.com/lue-bird/elm-keysset/blob/master/example/card)\n\n@docs Ordering\n\n\n## create\n\n@docs tie, Tie\n\n\n### ordering core types\n\n  - [`Char.Order`](Char-Order)\n  - [`Int.Order`](Int-Order)\n  - [`Float.Order`](Float-Order)\n  - in [`String.Order`](String-Order)\n  - in [`List.Order`](List-Order)\n\n\n### alter\n\n@docs reverse, Reverse, ReverseTag\n\n\n## combine\n\n@docs by, By, ByTag\n@docs onTie, OnTieNext, OnTieNextTag\n\n\n## choose\n\n@docs on, On, OnTag\n\n\n## transform\n\n@docs with\n\n\n## prior art\n\n  - [`matthewsj/elm-ordering`](https://dark.elm.dmy.fr/packages/matthewsj/elm-ordering/latest/Ordering)\n      - most complete\n      - bad naming `byField`: `byField Tuple.first`, ... are also possible\n      - clutter `isOrdered`, both `byField` & `byFieldWith`, ...\n      - verbose `... |> breakTiesWith ...` chain instead of `onTieNext [ ... ]`\n      - missing `list`, `maybe`, ... orderings\n  - [`TSFoster/elm-compare`](https://dark.elm.dmy.fr/packages/TSFoster/elm-compare/latest/Compare)\n      - API is a bit scuffed: multiple andThens will be nested instead of flat, ...\n      - missing `list`, `maybe`, ... compare operations\n  - [`rtfeldman/elm-sorter-experiment`](https://dark.elm.dmy.fr/packages/rtfeldman/elm-sorter-experiment/latest/Sort)\n      - wrapped in an opaque `type` → more verbose\n      - missing `list`, `maybe`, ... sorters\n      - `Sort.Set` & `Sort.Dict` are very nice! You can even use `Sort.Set.empty (Sorter.custom Order.x)` if you wanted\n  - [`nikita-volkov/`: `Typeclasses-Classes-Comparison`](https://package.elm-lang.org/packages/nikita-volkov/typeclasses/latest/Typeclasses-Classes-Comparison)\n      - almost no API, _only_ `int`,`float`,`comparable` & `map`)\n      - [`HashingContainers.HashSet`](https://package.elm-lang.org/packages/nikita-volkov/hashing-containers/2.1.0/HashingContainers-HashSet),\n        [`HashingContainers.HashDict`](https://package.elm-lang.org/packages/nikita-volkov/hashing-containers/2.1.0/HashingContainers-HashDict)\n        are nice!\n  - ... know others? → PR\n\n","unions":[{"name":"ByTag","comment":" Wrapper tag for [`By`](#By)\n","args":[],"cases":[]},{"name":"OnTag","comment":" Tag wrapper for [`On`](#On)\n","args":[],"cases":[]},{"name":"OnTieNextTag","comment":" Tag wrapper for [`OnTieNext`](#OnTieNext)\n","args":[],"cases":[]},{"name":"ReverseTag","comment":" Tag wrapper for [`Reverse`](#Reverse)\n","args":[],"cases":[]},{"name":"Tie","comment":" Tag for [`tie`](#tie)\n","args":[],"cases":[]}],"aliases":[{"name":"By","comment":" Tag for [`by`](#by)\n","args":["mapTag","mappedOrderTag"],"type":"( Order.ByTag, ( mapTag, mappedOrderTag ) )"},{"name":"On","comment":" Tags an attached [`on`](#on) possibility\n[`Mapping`](Map#Mapping)-[`Ordering`](#Ordering) pair\n","args":["toPossibility","order"],"type":"( Order.OnTag, ( toPossibility, order ) )"},{"name":"OnTieNext","comment":" Tag for [`onTie`](#onTie)\n","args":["orderTag","tieBreakingOrderTag"],"type":"( Order.OnTieNextTag, ( orderTag, tieBreakingOrderTag ) )"},{"name":"Ordering","comment":" How 2 thing compare to each other.\nAn `Ordering` can be used to `sortWith`, make comparisons, ...\n\n    cardsSort : List Card -> List Card\n    cardsSort =\n        List.sortWith (Order.with cardOrder)\n\n    cardOrder : Ordering Card\n\n","args":["complete","tag"],"type":"Map.Mapping ( complete, complete ) tag Basics.Order"},{"name":"Reverse","comment":" Tag for [`reverse`](#reverse)\n","args":["orderTag"],"type":"( Order.ReverseTag, orderTag )"}],"values":[{"name":"by","comment":" Order by a transformed value\n\n\n#### access a part\n\n    import Typed\n    import String.Order\n    import Char.Order\n    import Map exposing (Mapping)\n\n    type Name\n        = Name\n\n    name : Mapping { name : String } Name String\n    name =\n        Typed.tag Name .name\n\n    [ { name = \"Bo\" }, { name = \"Amy\" }, { name = \"Cam\" } ]\n        |> (List.sortWith << Order.with)\n            (Order.by name\n                (String.Order.earlier (Char.Order.aToZ Order.tie))\n            )\n    --> [ { name = \"Amy\" }, { name = \"Bo\" }, { name = \"Cam\" } ]\n\n    {-| `Order` `Tuple.first`, then on tie `Tuple.second`\n\n        Order.tuple ( Int.Order.up, Int.Order.up ) ( 0, 2 ) ( 0, -2 )\n        --→ GT\n    -}\n    tuple :\n        ( Ordering part0 part0OrderTag\n        , Ordering part1 part1OrderTag\n        )\n        -> Ordering\n                ( part0, part1 )\n                (Order.OnTieNext\n                    (Order.By Tuple.Map.Part0 part0OrderTag)\n                    (Order.By Tuple.Map.Part1 part1OrderTag)\n                )\n    tuple ( part0Order, part1Order ) =\n        Order.by Tuple.Map.part0 part0Order\n            |> Order.onTie\n                (Order.by Tuple.Map.part1 part1Order)\n\n\n#### unwrap a type union constructor\n\n    import Char.Order\n    import Order exposing (Ordering)\n    import String.Order\n\n    type User\n        = User { name : String }\n\n    userNameOrder : Ordering Username\n    userNameOrder =\n        Order.by (\\(User user) -> user)\n            (Order.by .name\n                (String.Order.earlier\n                    (Char.Order.aToZ Char.Order.lowerUpper)\n                )\n            )\n\n\n#### rank a simple choice\n\n    type Case\n        = Lower\n        | Upper\n\n    {-| `'A' < 'a'`\n    -}\n    upperLower : Ordering Case\n    upperLower =\n        Order.by\n            (\\case_ ->\n                case case_ of\n                    Upper ->\n                        0\n\n                    Lower ->\n                        1\n            )\n            Int.Order.up\n\nneat!\n\n","type":"Map.Mapping complete mapTag mapped -> Order.Ordering mapped mappedOrderTag -> Order.Ordering complete (Order.By mapTag mappedOrderTag)"},{"name":"on","comment":" Try ordering by a given parsed value.\nIn comparison to [`Order.by`](#by), mapping can produce `Nothing` in which case any `Just` value is greater.\n\nContinue by adding all possibilities with [`Order.onTie`](#onTie)\n\n    -- module Card exposing (Card(..), CardNormal, order)\n\n\n    import Order exposing (Ordering)\n    import RecordWithoutConstructorFunction exposing (RecordWithoutConstructorFunction)\n\n    type Card\n        = Normal CardNormal\n        | Joker\n\n    type alias CardNormal =\n        RecordWithoutConstructorFunction\n            { value : Value, suite : Suite }\n\n    type ToNormal\n        = ToNormal\n\n    normal : Mapping Card ToNormal (Maybe CardNormal)\n    normal =\n        Typed.tag ToNormal\n            (\\card ->\n                case card of\n                    Normal normalCard ->\n                        Just normalCard\n\n                    Joker ->\n                        Nothing\n            )\n\n    type alias NormalOrder =\n        Order.OnTieNext\n            (Order.By Suite SuiteOrder)\n            (Order.By Value ValueOrder)\n\n    normalOrder : Ordering CardNormal NormalOrder\n    normalOrder =\n        Order.by suite suiteOrder\n            |> Order.onTie\n                (Order.by value valueOrder)\n\n    order : Ordering Card (Order.On ToNormal NormalOrder)\n    order =\n        Order.on toNormal normalOrder\n\n    type Normal\n        = Normal\n\n    toNormal : Mapping Card Normal (Maybe CardNormal)\n    toNormal =\n        \\card ->\n            case card of\n                Normal normal ->\n                    normal |> Just\n\n                Joker ->\n                    Nothing\n\n_-- Advanced territory --_\n\nRecursive types need special treatment so we don't run into recursive types:\nRecursive [`Ordering`](#Ordering)s need a separate tag, e.g.\n\n    import Map\n    import Order\n    import Typed\n\n    type alias Earlier elementOrder =\n        Order.OnTieNext\n            (Order.On Empty Order.Tie)\n            (Order.On\n                Cons\n                (Order.OnTieNext\n                    (Order.By ConsElement elementOrder)\n                    (Order.By ConsList ( EarlierRecursive, elementOrder ))\n                )\n            )\n\n    type Empty\n        = Empty\n\n    toEmpty : Mapping (List element) Empty (Maybe ())\n    toEmpty =\n        Typed.tag Empty\n            (\\list ->\n                case list of\n                    [] ->\n                        Just ()\n\n                    _ :: _ ->\n                        Nothing\n            )\n\n    type Cons\n        = Cons\n\n    toCons : Mapping (List element) Cons (Maybe { element : element, list : List element })\n    toCons =\n        Typed.tag Cons\n            (\\list ->\n                case list of\n                    [] ->\n                        Nothing\n\n                    element :: list ->\n                        Just { element = element, list = list }\n            )\n\n    type ConsElement\n        = ConsElement\n\n    consElement : Mapping { element : element, list : List element } ConsList (List element)\n    consElement =\n        Typed.tag ConsList .list\n\n    type ConsList\n        = ConsList\n\n    consList : Mapping { element : element, list : List element } ConsList (List element)\n    consList =\n        Typed.tag ConsList .list\n\n    type EarlierRecursive\n        = EarlierRecursive\n\n    order : Ordering element elementOrder -> Ordering (List element) (Earlier elementOrder)\n    order elementOrder =\n        let\n            listRecursiveOrder : () -> Ordering (List element) ( EarlierRecursive, elementOrder )\n            listRecursiveOrder () =\n                Typed.mapToWrap EarlierRecursive order\n        in\n        Order.on toEmpty Order.tie\n            |> Order.onTie (Order.on toCons Order.by)\n\na bit much boilerplate.\n\n","type":"Map.Mapping choice toPossibilityTag (Maybe.Maybe possibilityAttachment) -> Order.Ordering possibilityAttachment possibilityOrderTag -> Order.Ordering choice (Order.On toPossibilityTag possibilityOrderTag)"},{"name":"onTie","comment":" Prioritize the [`Ordering`](#Ordering) by one aspect\nand break ties with the following\n\n    import Order exposing (Ordering)\n    import RecordWithoutConstructorFunction exposing (RecordWithoutConstructorFunction)\n\n    type alias Card =\n        RecordWithoutConstructorFunction\n            { suite : Suite, value : Value }\n\n([`RecordWithoutConstructorFunction`](https://dark.elm.dmy.fr/packages/lue-bird/elm-no-record-type-alias-constructor-function/latest/)\ntricks elm into not creating a `Card` function)\n\n    type Suite\n        = Clubs\n        | Hearts\n        | Diamonds\n        | Spades\n\n    type Value\n        = Two\n        | Three\n        | Four\n        | Five\n        | Six\n        | Seven\n        | Eight\n        | Nine\n        | Ten\n        | Jack\n        | Queen\n        | King\n        | Ace\n\n    cardOrder : Ordering Card (Order.OnTieNext (Order.By Suite SuiteOrder) (Order.By Value ValueOrder))\n    cardOrder =\n        Order.by suite suiteOrder\n            |> Order.onTieNext\n                (Order.by value valueOrder)\n\n    type SuiteToInt\n        = SuiteToInt\n\n    suiteToInt : Mapping Suite SuiteToInt Int\n    suiteToInt =\n        Typed.tag SuiteOrder\n            (\\suite ->\n                case suite of\n                    Clubs ->\n                        0\n\n                    Hearts ->\n                        1\n\n                    Diamonds ->\n                        2\n\n                    Spades ->\n                        3\n            )\n\n    type SuiteOrder =\n        Order.By SuiteToInt Int.Order.Up\n\n    suiteOrder : Ordering Suite SuiteOrder\n    suiteOrder =\n        Order.by suiteToInt Int.Order.up\n\n[`onTie`](#onTie) can also be used to order different variants and values → see [`on`](#on)\n\n","type":"Order.Ordering complete tieBreakingTag -> Order.Ordering complete tag -> Order.Ordering complete (Order.OnTieNext tag tieBreakingTag)"},{"name":"reverse","comment":" `a < b  ⇆  a > b`\n\n    import Char.Order\n    import String.Order\n\n    [ \"b\", \"c\", \"a\" ]\n        |> (List.sortWith << Order.with)\n            (String.Order.earlier\n                (Char.Order.aToZ Order.tie)\n            )\n    --> [ \"a\", \"b\", \"c\" ]\n\n    [ \"b\", \"c\", \"a\" ]\n        |> (List.sortWith << Order.with)\n            (String.Order.earlier\n                (Char.Order.aToZ Order.tie)\n                |> Order.reverse\n            )\n    --> [ \"c\", \"b\", \"a\" ]\n\n","type":"Order.Ordering complete tag -> Order.Ordering complete (Order.Reverse tag)"},{"name":"tie","comment":" Always `EQ` for any 2 things\n\n    Order.with tie 5555 -12345 --> EQ\n\n","type":"Order.Ordering complete_ Order.Tie"},{"name":"with","comment":" Convert to a function in the form `a -> a -> Order`\nthat can be used to `sortWith`, make comparisons, ...\n\n    cardsSort : List Card -> List Card\n    cardsSort =\n        List.sortWith (Order.with cardOrder)\n\n    cardOrder : Ordering Card\n\n","type":"Order.Ordering complete tag_ -> complete -> complete -> Basics.Order"}],"binops":[]},{"name":"String.Order","comment":" `String` [`Ordering`](Order#Ordering)\n\n@docs earlier, Earlier, EarlierTag\n\n","unions":[{"name":"EarlierTag","comment":" Wrapper tag for [`Earlier`](#Earlier)\n","args":[],"cases":[]}],"aliases":[{"name":"Earlier","comment":" Tag for [`earlier`](#earlier)\n","args":["elementOrder"],"type":"( String.Order.EarlierTag, elementOrder )"}],"values":[{"name":"earlier","comment":" `Order` `String`s by `Char`s first to last, specifying a [`Char` `Ordering`](Char-Order):\n\n    import Order\n    import Char.Order\n    import String.Order\n\n    Order.with\n        (String.Order.earlier\n            (Char.Order.aToZ Char.Order.lowerUpper)\n        )\n        \"hello, human!\"\n        \"hello, Human\"\n    --> LT\n\nFor string-number chunked text,\nyou can use [`mcordova47/`: `NaturalOrdering.compare`](https://dark.elm.dmy.fr/packages/mcordova47/elm-natural-ordering/latest/NaturalOrdering#compare)\n\n    NaturalOrdering.compare \"abc2.tff\" \"abc10.tff\"\n    --→ LT\n\nPersonally, I'd just store the `String` as something like\n\n    type TextChunked\n        = TextChunked ( String, Maybe (List ( Int, String )) )\n\nand order that\nto avoid converting too often\n\n","type":"Order.Ordering Char.Char charTag -> Order.Ordering String.String (String.Order.Earlier charTag)"}],"binops":[]}]