[{"name":"Array.Linear","comment":" `Array` operations that can be applied in either [`Direction`](Linear#Direction)\n\n\n## scan\n\n@docs element\n\n\n## transform\n\n@docs foldFrom\n\n\n### alter\n\n@docs elementRemove, elementReplace, elementAlter, insert\n@docs padToLength\n\n\n### part\n\n@docs take, drop, toChunksOf\n\n\n### glueing\n\n@docs glue, squeezeIn\n\n","unions":[],"aliases":[],"values":[{"name":"drop","comment":" Remove a given number of elements from one side\n\n    import Linear exposing (Direction(..))\n    import Array\n\n    Array.fromList [ 1, 2, 3, 4, 5, 6 ]\n        |> Array.Linear.drop ( Down, 2 )\n    --> Array.fromList [ 1, 2, 3, 4 ]\n\n    Array.fromList [ 1, 2, 3 ]\n        |> Array.Linear.drop ( Up, 100 )\n    --> Array.empty\n\nNothing is dropped if the amount of elements to drop is negative\n\n    import Linear exposing (Direction(..))\n    import Array\n\n    Array.fromList [ 1, 2, 3 ]\n        |> Array.Linear.drop ( Up, -1 )\n    --> Array.fromList [ 1, 2, 3 ]\n\n","type":"( Linear.Direction, Basics.Int ) -> Array.Array element -> Array.Array element"},{"name":"element","comment":" The element at a given index in a [`Direction`](Linear#Direction)\n\n    import Linear exposing (Direction(..))\n    import Array\n\n    Array.fromList [ \"lose\", \"win\", \"lose\" ]\n        |> Array.Linear.element ( Down, 0 )\n    --> Ok \"lose\"\n\n    Array.fromList [ \"lose\", \"win\", \"lose\" ]\n        |> Array.Linear.element ( Up, 0 )\n    --> Ok \"lose\"\n\n`Err` if the index is out of range\n\n    import Linear exposing (Direction(..), IndexIntOutOfRange(..))\n    import Array\n\n    Array.fromList [ 1, 2, 3 ]\n        |> Array.Linear.element ( Up, -1 )\n    --> Err IndexIntNegative\n\n    Array.fromList [ 1, 2, 3 ]\n        |> Array.Linear.element ( Up, 100 )\n    --> Err IndexIntBeyondElements\n\n","type":"( Linear.Direction, Basics.Int ) -> Array.Array element -> Result.Result Linear.IndexIntOutOfRange element"},{"name":"elementAlter","comment":" Set the element at an index in a [`Direction`](Linear#Direction)\n\n    import Linear exposing (Direction(..))\n    import Array\n\n    Array.fromList [ \"I\", \"am\", \"ok\" ]\n        |> Array.Linear.elementAlter ( Up, 2 )\n            String.toUpper\n    --> Array.fromList [ \"I\", \"am\", \"OK\" ]\n\n    Array.fromList [ \"I\", \"am\", \"ok\" ]\n        |> Array.Linear.elementAlter ( Down, 0 )\n            String.toUpper\n    --> Array.fromList [ \"I\", \"am\", \"OK\" ]\n\nIf the index is out of range, the `Array` is unaltered\n\n    import Linear exposing (Direction(..))\n    import Array\n\n    Array.fromList [ \"I\", \"am\", \"ok\" ]\n        |> Array.Linear.elementAlter ( Up, -1 )\n            String.toUpper\n    --> Array.fromList [ \"I\", \"am\", \"ok\" ]\n\n","type":"( Linear.Direction, Basics.Int ) -> (element -> element) -> Array.Array element -> Array.Array element"},{"name":"elementRemove","comment":" Kick an element out at a given index in a [`Direction`](Linear#Direction)\n\n    import Linear exposing (Direction(..))\n    import Array\n\n    Array.fromList [ 'a', 'a', 'b' ]\n        |> Array.Linear.elementRemove ( Up, 1 )\n    --> Array.fromList [ 'a', 'b' ]\n\n    Array.fromList [ 'a', 'b', 'c', 'd' ]\n        |> Array.Linear.elementRemove ( Down, 0 )\n    --> Array.fromList [ 'a', 'b', 'c' ]\n\nIf the index is out of bounds, nothing is changed\n\n    import Linear exposing (Direction(..))\n    import Array\n\n    Array.fromList [ 'a', 'a', 'b' ]\n        |> Array.Linear.elementRemove ( Up, -1 )\n    --> Array.fromList [ 'a', 'a', 'b' ]\n\n    Array.fromList [ 'a', 'a', 'b' ]\n        |> Array.Linear.elementRemove ( Up, 100 )\n    --> Array.fromList [ 'a', 'a', 'b' ]\n\n","type":"( Linear.Direction, Basics.Int ) -> Array.Array element -> Array.Array element"},{"name":"elementReplace","comment":" Set the element at an index in a [`Direction`](Linear#Direction)\n\n    import Linear exposing (Direction(..))\n    import Array\n\n    Array.fromList [ \"I\", \"am\", \"ok\" ]\n        |> Array.Linear.elementReplace ( Up, 2 )\n            (\\() -> \"confusion\")\n    --> Array.fromList [ \"I\", \"am\", \"confusion\" ]\n\n    Array.fromList [ \"I\", \"am\", \"ok\" ]\n        |> Array.Linear.elementReplace ( Down, 1 )\n            (\\() -> \"feel\")\n    --> Array.fromList [ \"I\", \"feel\", \"ok\" ]\n\nIf the index is out of range, the `Array` is unaltered\n\n    import Linear exposing (Direction(..))\n    import Array\n\n    Array.fromList [ \"I\", \"am\", \"ok\" ]\n        |> Array.Linear.elementReplace ( Up, -1 )\n            (\\() -> \"is\")\n    --> Array.fromList [ \"I\", \"am\", \"ok\" ]\n\n","type":"( Linear.Direction, Basics.Int ) -> (() -> element) -> Array.Array element -> Array.Array element"},{"name":"foldFrom","comment":" Reduce in a [`Direction`](Linear#Direction)\n\n    import Linear exposing (Direction(..))\n    import Array\n\n    Array.fromList [ 'l', 'i', 'v', 'e' ]\n        |> Array.Linear.foldFrom \"\" Up String.cons\n    --> \"evil\"\n\n    Array.fromList [ 'l', 'i', 'v', 'e' ]\n        |> Array.Linear.foldFrom \"\" Down String.cons\n    --> \"live\"\n\n","type":"accumulationValue -> Linear.Direction -> (element -> accumulationValue -> accumulationValue) -> Array.Array element -> accumulationValue"},{"name":"glue","comment":" Attach elements of an `Array`\nto the end in a given [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\n\n    import Linear exposing (Direction(..))\n    import Array\n\n    Array.fromList [ 1, 2, 3 ]\n        |> Array.Linear.glue Up (Array.fromList [ 4, 5, 6 ])\n    --> Array.fromList [ 1, 2, 3, 4, 5, 6 ]\n\n    Array.fromList [ 1, 2, 3 ]\n        |> Array.Linear.glue Down (Array.fromList [ 4, 5, 6 ])\n    --> Array.fromList [ 4, 5, 6, 1, 2, 3 ]\n\n","type":"Linear.Direction -> Array.Array element -> Array.Array element -> Array.Array element"},{"name":"insert","comment":" Put in a given element at a given index in a [`Direction`](Linear#Direction)\n\n    import Linear exposing (Direction(..))\n    import Array\n\n    Array.fromList [ 'a', 'c', 'd' ]\n        |> Array.Linear.insert ( Up, 1 )\n            (\\() -> 'b')\n    --> Array.fromList [ 'a', 'b', 'c', 'd' ]\n\n    Array.fromList [ 'a', 'c', 'd' ]\n        |> Array.Linear.insert ( Down, 2 )\n            (\\() -> 'b')\n    --> Array.fromList [ 'a', 'b', 'c', 'd' ]\n\nIf the index is out of bounds, **nothing is inserted**\n\n    import Linear exposing (Direction(..))\n    import Array\n\n    Array.fromList [ 'a', 'c', 'd' ]\n        |> Array.Linear.insert ( Up, -1 )\n            (\\() -> 'b')\n    --> Array.fromList [ 'a', 'c', 'd' ]\n\n    Array.fromList [ 'a', 'c', 'd' ]\n        |> Array.Linear.insert ( Up, 4 )\n            (\\() -> 'b')\n    --> Array.fromList [ 'a', 'c', 'd' ]\n\n[`squeezeIn`](#squeezeIn) allows inserting a whole `Array` of elements\n\n","type":"( Linear.Direction, Basics.Int ) -> (() -> element) -> Array.Array element -> Array.Array element"},{"name":"padToLength","comment":" **Pad** in a [`Direction`](Linear#Direction) based on how much it takes to reach at a given length\n\n    import Linear exposing (Direction(..))\n    import Array\n\n    Array.fromList [ 1, 2 ]\n        |> Array.Linear.padToLength Up\n            (\\l -> Array.repeat l 0)\n            4\n    --> Array.fromList [ 1, 2, 0, 0 ]\n\n    Array.fromList [ 1, 2 ]\n        |> Array.Linear.padToLength Down\n            (\\l -> Array.repeat l 0)\n            4\n    --> Array.fromList [ 0, 0, 1, 2 ]\n\n`padToLength direction ... length |> take ( direction, length )`\n→ **\"resize\"** behavior\n\n    Array.fromList [ 1, 2, 3 ]\n        |> Array.Linear.padToLength Up\n            (\\l -> Array.repeat l 0)\n            2\n        |> Array.Linear.take ( Up, 2 )\n    --> Array.fromList [ 1, 2 ]\n\n    Array.fromList [ 1, 2, 3 ]\n        |> Array.Linear.padToLength Down\n            (\\l -> Array.repeat l 0)\n            2\n        |> Array.Linear.take ( Down, 2 )\n    --> Array.fromList [ 2, 3 ]\n\n","type":"Linear.Direction -> (Basics.Int -> Array.Array element) -> Basics.Int -> Array.Array element -> Array.Array element"},{"name":"squeezeIn","comment":" Put elements of a given `Array` between the elements left and right to the given index in a [`Direction`](Linear#Direction)\n\n    import Linear exposing (Direction(..))\n    import Array\n\n    Array.fromList [ 'a', 'd', 'e' ]\n        |> Array.Linear.squeezeIn ( Up, 1 )\n            (\\() -> Array.fromList [ 'b', 'c' ])\n    --> Array.fromList [ 'a', 'b', 'c', 'd', 'e' ]\n\n    Array.fromList [ 'a', 'd', 'e' ]\n        |> Array.Linear.squeezeIn ( Down, 2 )\n            (\\() -> Array.fromList [ 'b', 'c' ])\n    --> Array.fromList [ 'a', 'b', 'c', 'd', 'e' ]\n\nIf the index is outside of the `Array`'s range, **nothing is inserted**\n\n    import Linear exposing (Direction(..))\n    import Array\n\n    Array.fromList [ 'a', 'd', 'e' ]\n        |> Array.Linear.squeezeIn ( Up, -1 )\n            (\\() -> Array.fromList [ 'b', 'c' ])\n    --> Array.fromList [ 'a', 'd', 'e' ]\n\n    Array.fromList [ 'a', 'd', 'e' ]\n        |> Array.Linear.squeezeIn ( Up, 4 )\n            (\\() -> Array.fromList [ 'b', 'c' ])\n    --> Array.fromList [ 'a', 'd', 'e' ]\n\n[`insert`](#insert) allows inserting a single element\n\n","type":"( Linear.Direction, Basics.Int ) -> (() -> Array.Array element) -> Array.Array element -> Array.Array element"},{"name":"take","comment":" A given number of elements from one side\n\n    import Linear exposing (Direction(..))\n    import Array\n\n    Array.fromList [ 1, 2, 3, 4, 5, 6 ]\n        |> Array.Linear.take ( Up, 4 )\n        |> Array.Linear.take ( Down, 2 )\n    --> Array.fromList [ 3, 4 ]\n\n    Array.fromList [ 1, 2, 3 ]\n        |> Array.Linear.take ( Up, 100 )\n    --> Array.fromList [ 1, 2, 3 ]\n\n`Array.empty` if the amount of elements to take is negative\n\n    import Linear exposing (Direction(..))\n    import Array\n\n    Array.fromList [ 1, 2, 3 ]\n        |> Array.Linear.take ( Up, -100 )\n    --> Array.empty\n\n","type":"( Linear.Direction, Basics.Int ) -> Array.Array element -> Array.Array element"},{"name":"toChunksOf","comment":" Split into equal-sized `chunks` of a given length in a given [`Direction`](Linear#Direction).\nThe left over elements to one side are in `remainder`\n\n    import Linear exposing (Direction(..))\n    import Array\n\n    Array.fromList [ 1, 2, 3, 4, 5, 6, 7 ]\n        |> Array.Linear.toChunksOf Up 3\n    --> { chunks =\n    -->     Array.fromList\n    -->         [ Array.fromList [ 1, 2, 3 ]\n    -->         , Array.fromList [ 4, 5, 6 ]\n    -->         ]\n    --> , remainder = Array.fromList [ 7 ]\n    --> }\n\n    Array.fromList [ 1, 2, 3, 4, 5, 6, 7 ]\n        |> Array.Linear.toChunksOf Down 3\n    --> { remainder = Array.fromList [ 1 ]\n    --> , chunks =\n    -->     Array.fromList\n    -->         [ Array.fromList [ 2, 3, 4 ]\n    -->         , Array.fromList [ 5, 6, 7 ]\n    -->         ]\n    --> }\n\n","type":"Linear.Direction -> Basics.Int -> Array.Array element -> { chunks : Array.Array (Array.Array element), remainder : Array.Array element }"}],"binops":[]},{"name":"Case","comment":" Casing\n\n@docs Case\n\n\n## order\n\n@docs lowerUpper, upperLower\n\n","unions":[{"name":"Case","comment":" `Case` of a letter. [`Ordering`](Order#Ordering)s:\n\n  - [`Case.lowerUpper`](#lowerUpper)\n  - [`Case.upperLower`](#upperLower)\n  - [`Order.tie`](Order#tie)\n\n","args":[],"cases":[["Lower",[]],["Upper",[]]]}],"aliases":[],"values":[{"name":"lowerUpper","comment":" `'a' < 'A'`\n","type":"Order.Ordering Case.Case"},{"name":"upperLower","comment":" `'A' < 'a'`\n","type":"Order.Ordering Case.Case"}],"binops":[]},{"name":"Char.Order","comment":" `Order` `Char`s\n\n@docs alphabetically\n\n","unions":[],"aliases":[],"values":[{"name":"alphabetically","comment":" `Order` `Char`s\n\n  - Both are letters → `Order` alphabetically\n      - They're the same picture? → a given [`Ordering`](Order#Ordering) on their cases\n  - Just one isn't a letter → `Order` according to unicode char code\n\n```\nimport Case\n\nChar.Order.alphabetically Case.upperLower 'b' 'D'\n--> LT\n\nChar.Order.alphabetically Case.upperLower 'l' 'L'\n--> GT\n```\n\n","type":"Order.Ordering Case.Case -> Order.Ordering Char.Char"}],"binops":[]},{"name":"Dict.Linear","comment":" `Dict` operations that can be applied in either [`Direction`](Linear#Direction)\n\n\n## transform\n\n@docs foldFrom\n\n","unions":[],"aliases":[],"values":[{"name":"foldFrom","comment":" Reduce `{ key, value }`-entries in a [`Direction`](Linear#Direction)\n\n    import Linear exposing (Direction(..))\n    import Dict\n\n    Dict.fromList\n        [ ( \"Dies\", 39 ), ( \"Wonu\", 22 ), ( \"Eorfe\", 18 ) ]\n        |> Dict.Linear.foldFrom [] Up (\\user -> (::) user.key)\n    --> [ \"Wonu\", \"Eorfe\", \"Dies\" ]\n\n    Dict.fromList\n        [ ( \"Dies\", 39 ), ( \"Wonu\", 22 ), ( \"Eorfe\", 18 ) ]\n        |> Dict.Linear.foldFrom [] Down (\\user -> (::) user.key)\n    --> [ \"Dies\", \"Eorfe\", \"Wonu\" ]\n\n","type":"accumulationValue -> Linear.Direction -> ({ key : key, value : value } -> accumulationValue -> accumulationValue) -> Dict.Dict key value -> accumulationValue"}],"binops":[]},{"name":"Float.Order","comment":" `Order` `Float`s\n\n@docs increasing, decreasing\n\n","unions":[],"aliases":[],"values":[{"name":"decreasing","comment":" `Order` `Float`s where higher means greater\n\n    Float.Order.decreasing 2.1 40.34\n    --> GT\n\n","type":"Order.Ordering Basics.Float"},{"name":"increasing","comment":" `Order` `Float`s where lower means greater\n\n    Float.Order.increasing 40.34 2.1\n    --> GT\n\n","type":"Order.Ordering Basics.Float"}],"binops":[]},{"name":"Int.Order","comment":" `Order` `Int`s\n\n@docs increasing, decreasing\n\n","unions":[],"aliases":[],"values":[{"name":"decreasing","comment":" `Order` `Int`s where higher means greater\n\n    Int.Order.decreasing 2 40\n    --> GT\n\n","type":"Order.Ordering Basics.Int"},{"name":"increasing","comment":" `Order` `Int`s where lower means greater\n\n    Int.Order.increasing 40 2\n    --> GT\n\n","type":"Order.Ordering Basics.Int"}],"binops":[]},{"name":"Linear","comment":" `Up` or `Down` a structure\n\n@docs Direction\n\n\n## create\n\n@docs directionFuzz\n\n\n## alter\n\n@docs opposite\n\n\n## index\n\n@docs IndexIntOutOfRange\n\n","unions":[{"name":"Direction","comment":" Either\n\n  - `Up` towards the end where indexes are getting bigger\n  - `Down` towards the beginning where indexes are getting smaller\n\n","args":[],"cases":[["Up",[]],["Down",[]]]},{"name":"IndexIntOutOfRange","comment":" Locating an element at a given index `Int` fails if its\n\n  - `<= -1`\n  - `>=` the structure's length\n\n","args":[],"cases":[["IndexIntNegative",[]],["IndexIntBeyondElements",[]]]}],"aliases":[],"values":[{"name":"directionFuzz","comment":" [`Direction`](#Direction) `Fuzzer`\n","type":"Fuzz.Fuzzer Linear.Direction"},{"name":"opposite","comment":" The other [`Direction`](#Direction): `Down` ⇆ `Up`\n","type":"Linear.Direction -> Linear.Direction"}],"binops":[]},{"name":"List.Linear","comment":" `List` operations that can be applied in either [`Direction`](Linear#Direction)\n\n\n## scan\n\n@docs element\n\n\n## transform\n\n@docs foldFrom, foldTrace, foldTraceFrom\n\n@docs elementAlter\n\n\n### part\n\n@docs take, drop\n@docs toChunksOf\n\n","unions":[],"aliases":[],"values":[{"name":"drop","comment":" Remove a given number of elements from one side in a [`Direction`](Linear#Direction)\n\n    import Linear exposing (Direction(..))\n\n    removeFirst =\n        List.Linear.drop ( Up, 0 )\n\n    removeLast =\n        List.Linear.drop ( Down, 0 )\n\nNothing is dropped if the amount of elements to drop is negative\n\n    import Linear exposing (Direction(..))\n\n    [ 1, 2, 3 ]\n        |> List.Linear.drop ( Up, -1 )\n    --> [ 1, 2, 3 ]\n\n","type":"( Linear.Direction, Basics.Int ) -> List.List element -> List.List element"},{"name":"element","comment":" `Just` the element at the given index in a [`Direction`](Linear#Direction)\n\n    import Linear exposing (Direction(..))\n\n    [ 0, 1, 2, 3 ]\n        |> List.Linear.element ( Down, 0 )\n    --> Ok 3\n\n    [ 0, 1, 2, 3 ]\n        |> List.Linear.element ( Up, 2 )\n    --> Ok 2\n\n`Err` if the index is out of range:\n\n    import Linear exposing (Direction(..), IndexIntOutOfRange(..))\n\n    [ 0, 1, 2, 3 ]\n        |> List.Linear.element ( Up, 5 )\n    --> Err IndexIntBeyondElements\n\n    [ 0, 1, 2, 3 ]\n        |> List.Linear.element ( Up, -1 )\n    --> Err IndexIntNegative\n\nIf you're using at-operations often, consider using an `Array` instead of a `List`\nto get `O(log n)` vs. `O(n)` random access performance\n\n","type":"( Linear.Direction, Basics.Int ) -> List.List element -> Result.Result Linear.IndexIntOutOfRange element"},{"name":"elementAlter","comment":" Alter the element at the given index in a [`Direction`](Linear#Direction)\n\n    import Linear exposing (Direction(..))\n\n    [ 1, 2, 2 ]\n        |> List.Linear.elementAlter ( Down, 0 )\n            (\\n -> n + 1)\n    --> [ 1, 2, 3 ]\n\nDo nothing if the index is out of range\n\n    import Linear exposing (Direction(..))\n\n    [ 0, 1, 2, 3 ]\n        |> List.Linear.elementAlter ( Up, 4 )\n            (\\_ -> 123)\n    --> [ 0, 1, 2, 3 ]\n\n    [ 0, 1, 2, 3 ]\n        |> List.Linear.elementAlter ( Up, -1 )\n            (\\_ -> 123)\n    --> [ 0, 1, 2, 3 ]\n\nIf you're using at-operations often, consider using an `Array` instead of a `List`\nto get `O(log n)` vs. `O(n)` random access performance\n\n","type":"( Linear.Direction, Basics.Int ) -> (element -> element) -> List.List element -> List.List element"},{"name":"foldFrom","comment":" Reduce in a [`Direction`](Linear#Direction)\n\n    import Linear exposing (Direction(..))\n\n    [ 'l', 'i', 'v', 'e' ]\n        |> List.Linear.foldFrom \"\" Up String.cons\n    --> \"evil\"\n\n    [ 'l', 'i', 'v', 'e' ]\n        |> List.Linear.foldFrom \"\" Down String.cons\n    --> \"live\"\n\n","type":"accumulationValue -> Linear.Direction -> (element -> accumulationValue -> accumulationValue) -> List.List element -> accumulationValue"},{"name":"foldTrace","comment":" [`foldTraceFrom`](#foldTraceFrom) its first element\nlooking in a given [`Direction`](Linear#Direction)\n\n    import Linear exposing (Direction(..))\n\n    [ 1, 2, 3 ]\n        |> List.Linear.foldTrace Down (\\el soFar -> soFar + el)\n    --> [ 3, 5, 6 ]\n\n    [ 1, 2, 3 ]\n        |> List.Linear.foldTrace Down (\\el soFar -> soFar - el)\n    --> [ 3, 1, 0 ]\n\n","type":"Linear.Direction -> (element -> element -> element) -> List.List element -> List.List element"},{"name":"foldTraceFrom","comment":" Reduce in a given [`Direction`](Linear#Direction),\nstacking up all of the intermediate results\n\n    import Linear exposing (Direction(..))\n\n    [ 1, 2, 3, 4 ]\n        |> List.Linear.foldTraceFrom 0 Up (\\el soFar -> soFar + el)\n    --> [ 1, 3, 6, 10 ]\n\n    [ 1, 2, 3 ]\n        |> List.Linear.foldTraceFrom 0 Down (\\el soFar -> soFar - el)\n    --> [ -3, -5, -6 ]\n\n","type":"accumulationValue -> Linear.Direction -> (element -> accumulationValue -> accumulationValue) -> List.List element -> List.List accumulationValue"},{"name":"take","comment":" A given number of elements from one side in a [`Direction`](Linear#Direction)\n\n    import Linear exposing (Direction(..))\n\n    [ 1, 2, 3, 4 ]\n        |> List.Linear.take ( Up,2 )\n    --> [ 1, 2 ]\n\n    [ 1, 2, 3, 4 ]\n        |> List.Linear.take ( Down, 2 )\n    --> [ 3, 4 ]\n\n`[]` if the amount of elements to take is negative\n\n    import Linear exposing (Direction(..))\n\n    [ 1, 2, 3 ]\n        |> List.Linear.take ( Up, -100 )\n    --> []\n\n","type":"( Linear.Direction, Basics.Int ) -> List.List element -> List.List element"},{"name":"toChunksOf","comment":" Split into equal-sized `chunks` of a given length in a given [`Direction`](Linear#Direction)\nThe left over elements to one side are in `remainder`\n\n    import Linear exposing (Direction(..))\n\n    [ 1, 2, 3, 4, 5, 6, 7 ]\n        |> List.Linear.toChunksOf Up 3\n    --> { chunks = [ [ 1, 2, 3 ], [ 4, 5, 6 ] ]\n    --> , remainder = [ 7 ]\n    --> }\n\n    [ 1, 2, 3, 4, 5, 6, 7 ]\n        |> List.Linear.toChunksOf Down 3\n    --> { remainder = [ 1 ]\n    --> , chunks = [ [ 2, 3, 4 ], [ 5, 6, 7 ] ]\n    --> }\n\n","type":"Linear.Direction -> Basics.Int -> List.List element -> { chunks : List.List (List.List element), remainder : List.List element }"}],"binops":[]},{"name":"List.Order","comment":" `Order` `List`s\n\n@docs greaterEarlier\n\n","unions":[],"aliases":[],"values":[{"name":"greaterEarlier","comment":" Order `List`s by elements first to last\n\n    import Int.Order\n\n    List.Order.greaterEarlier Int.Order.increasing\n        [ 11, 22, 33, 188 ]\n        [ 11, 22, 34 ]\n    --> LT\n\n","type":"Order.Ordering element -> Order.Ordering (List.List element)"}],"binops":[]},{"name":"Maybe.Order","comment":" `Order` `Maybe`s\n\n@docs nothingJust\n\n","unions":[],"aliases":[],"values":[{"name":"nothingJust","comment":" `Order` `Nothing` < `Just`\n\n    import Int.Order\n\n    Maybe.Order.nothingJust Int.Order.increasing\n        (Just -99999)\n        Nothing\n    --> GT\n\n","type":"Order.Ordering content -> Order.Ordering (Maybe.Maybe content)"}],"binops":[]},{"name":"Order","comment":" Comparing 2 things\n\n@docs Ordering\n\n@docs tie\n\n\n### alter\n\n@docs by, reverse\n\n\n## combine\n\n@docs onTieNext\n\n\n## primitive\n\n  - [`Case`](Case)\n  - [`Char.Order`](Char-Order)\n  - [`Int.Order`](Int-Order)\n  - [`Float.Order`](Float-Order)\n  - [`String.Order`](String-Order)\n  - [`List.Order`](List-Order)\n  - [`Maybe.Order`](Maybe-Order)\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":[],"aliases":[{"name":"Ordering","comment":" How 2 thing compare to each other.\nAn `Ordering` can be used directly to `sortWith`, make comparisons, ...\n\n    cardsSort : List Card -> List Card\n    cardsSort =\n        List.sortWith cardOrder\n\n    cardOrder : Ordering Card\n\n","args":["orderable"],"type":"orderable -> orderable -> Basics.Order"}],"values":[{"name":"by","comment":" `Order` by a transformed value. Examples:\n\n\n#### access a part\n\n    import String.Order\n    import Char.Order\n\n    [ { name = \"Bo\" }, { name = \"Amy\" }, { name = \"Cam\" } ]\n        |> List.sortWith\n            (Order.by .name\n                (String.Order.greaterEarlier (Char.Order.alphabetically 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.increasing, Int.Order.increasing ) ( 0, 2 ) ( 0, -2 )\n        --→ GT\n    -}\n    tuple : ( Ordering part0, Ordering part1 ) -> Ordering ( part0, part1 )\n    tuple ( part0Order, part1Order ) =\n        Order.onTieNext\n            [ Order.by Tuple.first part0Order\n            , Order.by Tuple.second part1Order\n            ]\n\n\n#### unwrap a type union constructor\n\n    import Case\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.greaterEarlier (Char.Order.alphabetically Case.lowerUpper))\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.increasing\n\n\n#### rank a choice\n\n    module Card exposing (Card(..), CardNormal, order)\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    normalOrder : Ordering CardNormal\n    normalOrder =\n        Order.onTieNext\n            [ Order.by .suite suiteOrder\n            , Order.by .value valueOrder\n            ]\n\n    order : Ordering Card\n    order =\n        \\card0 card1 ->\n            case ( card0, card1 ) of\n                -- match all variants with _values_\n                ( Normal normal0, Normal normal1 ) ->\n                    normalOrder normal0 normal1\n\n                ( other0, other1 ) ->\n                    -- sort others according to tag \"rank\"\n                    Order.by\n                        (\\card ->\n                            case card of\n                                Normal _ ->\n                                    0\n\n                                Joker ->\n                                    1\n                        )\n                        Int.Order.increasing\n                        other0\n                        other1\n\nUse ↑ once your type union grows to have lots of variants\nwhere exhaustive matching has n^2 branches\n\nFor simple type unions with only 2 variants:\n\n    order : Ordering Card\n    order =\n        \\card0 card1 ->\n            case ( card0, card1 ) of\n                -- match all variants with _values_\n                ( Normal normal0, Normal normal1 ) ->\n                    normalOrder normal0 normal1\n\n                ( Normal _, Joker ) ->\n                    GT\n\n                ( Joker, Normal _ ) ->\n                    LT\n\n                ( Joker, Joker ) ->\n                    EQ\n\nPretty neat stuff!\n\n","type":"(orderable -> orderableMapped) -> Order.Ordering orderableMapped -> Order.Ordering orderable"},{"name":"onTieNext","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\n    cardOrder =\n        Order.onTieNext\n            [ Order.by .suite suiteOrder\n            , Order.by .value valueOrder\n            ]\n\n    suiteOrder : Ordering Suite\n    suiteOrder =\n        Order.by\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            Int.Order.increasing\n\n","type":"List.List (Order.Ordering orderable) -> Order.Ordering orderable"},{"name":"reverse","comment":" `a < b  ⇆  a > b`\n\n    import Char.Order\n    import String.Order\n\n    [ \"b\", \"c\", \"a\" ]\n        |> List.sortWith\n            (String.Order.greaterEarlier\n                (Char.Order.alphabetically Order.tie)\n            )\n    --> [ \"a\", \"b\", \"c\" ]\n\n    [ \"b\", \"c\", \"a\" ]\n        |> List.sortWith\n            (String.Order.greaterEarlier\n                (Char.Order.alphabetically Order.tie)\n                |> Order.reverse\n            )\n    --> [ \"c\", \"b\", \"a\" ]\n\n","type":"Order.Ordering orderable -> Order.Ordering orderable"},{"name":"tie","comment":" Always `EQ` for any 2 things\n\n    tie 5555 -12345 --> EQ\n\n","type":"Order.Ordering orderable_"}],"binops":[]},{"name":"Set.Linear","comment":" `Set` operations that can be applied in either [`Direction`](Linear#Direction)\n\n\n## transform\n\n@docs foldFrom\n\n","unions":[],"aliases":[],"values":[{"name":"foldFrom","comment":" Reduce in a [`Direction`](Linear#Direction)\n\n    import Linear exposing (Direction(..))\n    import Set\n\n    Set.fromList [ 'i', 'l', 'a', 'g' ]\n        |> Set.Linear.foldFrom \"\" Up String.cons\n    --> \"liga\"\n\n    Set.fromList [ 'i', 'l', 'a', 'g' ]\n        |> Set.Linear.foldFrom \"\" Down String.cons\n    --> \"agil\"\n\n","type":"accumulationValue -> Linear.Direction -> (element -> accumulationValue -> accumulationValue) -> Set.Set element -> accumulationValue"}],"binops":[]},{"name":"String.Order","comment":" `Order` `String`s\n\n@docs greaterEarlier\n\n","unions":[],"aliases":[],"values":[{"name":"greaterEarlier","comment":" `Order` `String`s by `Char`s first to last, specifying a [`Char` `Ordering`](Char-Order):\n\n    import Case\n    import Char.Order\n    import String.Order\n\n    String.Order.greaterEarlier (Char.Order.alphabetically Case.lowerUpper)\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 -> Order.Ordering String.String"}],"binops":[]}]