[{"name":"ArraySized","comment":" An `Array` that knows more about the amount of elements it holds\n\n    import Linear exposing (Direction(..))\n    import N exposing (n0)\n    import Array\n\n    Array.empty |> Array.get 0\n    --> Nothing\n\n    ArraySized.empty |> ArraySized.element ( Up, n0 )\n    -- compile-time error\n\nIs this any useful? One example:\n\n> You have an array of 1+ elements. What's its greatest value?\n\n    withArray : Array comparable -> Maybe comparable\n    withArray =\n        Array.foldl\n            (\\element soFar ->\n                case soFar of\n                    Just maxSoFar ->\n                        max maxSoFar element\n\n                    Nothing ->\n                        element\n            )\n            Nothing\n\n    withArraySized :\n        ArraySized comparable (In (On (Add1 minFrom1_)) max_)\n        -> comparable\n    withArraySized =\n        ArraySized.fold Up Basics.max\n\nThe `Array` type can't express it contains 1+ elements.\n[`ArraySized`](#ArraySized) knows about its length at compile time,\nso we can [`fold`](#fold), access, ... without a worry\n\n@docs ArraySized\n\n\n# create\n\n@docs repeat, n1To, random, fuzz, inFuzz\n@docs fromArray, fromList, fromEmptiable, fromStack, fromString\n\n\n## specific length\n\n@docs empty, one\n\n[⏭ skip to last](ArraySized#l16)\n\n@docs l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13, l14, l15, l16\n\nYou can [generate `l<n>` with `n >= 17` locally](https://lue-bird.github.io/elm-typesafe-array/generate/),\nput them in a `module ArraySized.Local exposing (l<n>, ...)` + `import ArraySized.Local as ArraySized`\n\n\n# observe\n\n@docs length\n@docs element, elementTry, toOne\n\nSearching for all, any? → [`allFill`](#allFill)\n\n\n## observe length\n\n@docs hasIn, has, hasAtLeast, hasAtMost\n\n\n# alter\n\n@docs elementReplace, elementAlter, reverse, andIndexes, map, mapFoldFrom\n@docs push, pushMin, insert, insertMin\n@docs remove, removeMin\n\n\n## filter\n\n@docs fills, allFill, allOk\n\n\n## part\n\n@docs take, takeCurrentMin, drop, dropMin, dropMax, toSize\n@docs toChunksOf\n\n\n## combine\n\n@docs and\n@docs attach, attachMin\n@docs interweave, interweaveMin\n\n\n# transform\n\n@docs foldFrom, fold, foldFromOne\n@docs toArray, toList, toEmptiable, toStack, toString\n\nYou have a use-case for `mapAccumulate`/`mapAccumulateFrom`? → issue/PR\n\n@docs to2\n\n[⏭ skip to last](ArraySized#to16)\n\n@docs to3, to4, to5, to6, to7, to8, to9, to10, to11, to12, to13, to14, to15, to16\n\nYou can [generate `to<x>` with `x >= 17` locally](https://lue-bird.github.io/elm-typesafe-array/generate/),\nput them in a `module exposing (to<x>)` + `import as ArraySized`\n\n\n## without internal functions\n\n@docs inToNumber, inToOn\n@docs minToNumber, minToOn\n@docs maxToNumber, maxToOn\n\n\n## type-level\n\n@docs minTo, minTo0, minSubtract, minEndsSubtract\n@docs maxTo, maxToInfinity, maxAdd, maxEndsSubtract\n\n\n### advanced: generic [`allowable-state`](https://dark.elm.dmy.fr/packages/lue-bird/elm-allowable-state/latest/)\n\n@docs hasAtLeast1, min0Adapt, minAtLeast1Never\n\n","unions":[],"aliases":[{"name":"ArraySized","comment":" An `Array` that knows about the amount of elements it holds.\n\n\n### result type\n\n    -- length >= 5\n    : ArraySized ... (Min (Up5 x_))\n\n    -- 2 <= length <= 12\n    : ArraySized ... (In (Up2 minX_) (Up12 maxX_))\n\nRepresenting a result's numbers as this weird `Up<n> x`\nis what allows the little magic tricks in the library:\n[attaching](#combine), [taking, dropping, chunking](#part), [comparing](#observe-length), ...\n\n\n### argument type\n\n    -- length = 15\n    : ArraySized ... (Exactly (On N15))\n\n    -- length >= 4\n    : ArraySized ... (In (On (Add4 minFrom4_)) max_)\n\n    -- 4 <= length <= 15\n    : ArraySized ...\n    :     (In (On (Add4 minFrom4_)) (Up maxTo15_ To N15))\n\nto allow the broadest range of desired lengths,\n\n  - to require nothing about the upper limit\n    → leave the maximum as a variable\n  - fix lower limits to the desired minimum number `+` some variable\n  - require the actual upper limit to go `Up` a variable amount\n    to arrive at the desired maximum number\n\n\n### stored type\n\nin your `Model` for example.\nThey look just like [result types](#result-type) but every\n`Up<n> x` becomes `On N<n>`,\navoiding type variables\n\n    -- length >= 4\n    : ArraySized ... (Min (On N4))\n\n    -- 4 <= length <= 15\n    : ArraySized ... (In (On N4) (On N15))\n\n    -- length = 15\n    : ArraySized ... (Exactly (On N15))\n\n`==` on both [`ArraySized`](#ArraySized)s and `N`s crashes elm.\n[Compare safely](#observe-length)\nor convert [`inToNumber`](#inToNumber)\n\n","args":["element","lengthRange"],"type":"ArraySized.Internal.ArraySized element lengthRange"}],"values":[{"name":"allFill","comment":" If every `Emptiable` is `filled`, all of the values.\nIf any element is `empty`, `empty`\n\n    import Emptiable exposing (filled)\n\n    ArraySized.empty\n        |> ArraySized.allFill\n        |> Emptiable.map ArraySized.toList\n    --> filled []\n\n    ArraySized.l3 (filled 1) (filled 2) (filled 3)\n        |> ArraySized.allFill\n        |> Emptiable.map ArraySized.toList\n    --> filled [ 1, 2, 3 ]\n\n    ArraySized.l3 (filled 1) Emptiable.empty (filled 3)\n        |> ArraySized.allFill\n    --> Emptiable.empty\n\nCan also be used to check whether all/any elements satisfy a given test\n\n    import Possibly exposing (Possibly)\n    import Emptiable exposing (Emptiable)\n\n\n    atMost4 : Int -> Emptiable Int Possibly\n    atMost4 =\n        \\n ->\n            if n <= 4 then\n                n |> Emptiable.filled\n            else\n                Emptiable.empty\n\n    -- all\n\n\n    ArraySized.l2 2 3\n        |> ArraySized.map atMost4\n        |> ArraySized.allFill\n        |> (/=) Emptiable.empty\n    --> True\n\n    ArraySized.l2 2 7\n        |> ArraySized.map atMost4\n        |> ArraySized.allFill\n        |> (/=) Emptiable.empty\n    --> False\n\n\n    -- any\n\n\n    ArraySized.l2 -5 300\n        |> ArraySized.map atMost4\n        |> ArraySized.allFill\n        |> (==) Emptiable.empty\n    --> True\n\n    ArraySized.l2 0 0\n        |> ArraySized.map atMost4\n        |> ArraySized.allFill\n        |> (==) Emptiable.empty\n    --> False\n\nQ: Why not expose `any`, `all`?\n\n> A: to push you towards [parsing, not validating](https://elm-radio.com/episode/parse-dont-validate/)\n\nFunny aside, [`allFill`](#allFill) can sometimes even be nicer than `mapN`/`andMap`\n\n    groupCall =\n        ArraySized.l5 aUser bUser cUser dUser eUser\n            |> ArraySized.map .phoneNumber\n            |> ArraySized.allFill\n\n    -- vs\n    groupCall =\n        map5 ArraySized.l5\n            aUser.phoneNumber\n            bUser.phoneNumber\n            cUser.phoneNumber\n            dUser.phoneNumber\n            eUser.phoneNumber\n\n","type":"ArraySized.ArraySized (Emptiable.Emptiable fill possiblyOrNever) range -> Emptiable.Emptiable (ArraySized.ArraySized fill range) possiblyOrNever"},{"name":"allOk","comment":" If every `Result` is `Ok`, all of the values.\nIf any element is `Err`, all the errors.\n\n    import Stack\n\n    ArraySized.empty\n        |> ArraySized.allOk\n        |> Result.map ArraySized.toList\n    --> Ok []\n\n    ArraySized.l3 (Ok 1) (Ok 2) (Ok 3)\n        |> ArraySized.allOk\n        |> Result.map ArraySized.toList\n    --> Ok [ 1, 2, 3 ]\n\n    ArraySized.l3 (Ok 1) (Err \"not a number\") (Ok 3)\n        |> ArraySized.allOk\n    --> Err (Stack.one \"not a number\")\n\n","type":"ArraySized.ArraySized (Result.Result error ok) range -> Result.Result (Emptiable.Emptiable (Stack.Stacked error) Basics.Never) (ArraySized.ArraySized ok range)"},{"name":"and","comment":" Combine each element with an element at the same index from a given [`ArraySized`](#ArraySized) into a tuple\n\nEvery element beyond the minimum [`length`](#length) of both is't part of the final [`ArraySized`](#ArraySized)\n\n    import ArraySized\n\n    answer\n        |> ArraySized.and guess\n        |> ArraySized.map\n            (\\( answerChar, guessChar ) ->\n                { directMatch = guessChar == answerChar }\n            )\n\nThis is often misused\n\n  - multiple structures for different attributes of the same thing\n      - example: one list for exercises, one matching the cards' indexes with progress\n      - these should be in the same structure\n  - applying multiple changes for a sequence of indexes\n      - example: <https://github.com/Rototu/storefront/blob/f8fe0b7cb823e3a50f175985a13762f9482ae4a8/frontend/src/Page/Home.elm#L24-L32>\n      - each of those indices seem to have special meaning. Use a record to gain type-safety and be more descriptive\n  - stupid stuff where another operation like map would be more appropriate\n      - example: <https://github.com/dclutr/a-toastmasters-certificates-tool/blob/0cb97c2766c6c51bb32881a1e7c77beb21b1c32a/Main.elm#L165-L172>\n\n","type":"ArraySized.ArraySized nextElement range -> ArraySized.ArraySized element range -> ArraySized.ArraySized ( element, nextElement ) range"},{"name":"andIndexes","comment":" Add index info to each element.\n\n    import N exposing (n1, n2, n3)\n\n    ArraySized.l3 'a' 'b' 'c'\n        |> ArraySized.andIndexes\n        |> ArraySized.toList\n    --→ [ { element = 'a', index = n1 |> N.maxTo n3 }\n    --→ , { element = 'b', index = n2 |> N.minTo n1 |> N.maxTo n3 }\n    --→ , { element = 'b', index = n3 |> N.minTo n1 }\n    --→ ]\n\n","type":"ArraySized.ArraySized element (N.In (N.Up minX N.To minPlusX) max) -> ArraySized.ArraySized { element : element, index : N.N (N.In (N.Up1 nMinX_) max) } (N.In (N.Up minX N.To minPlusX) max)"},{"name":"attach","comment":" Glue elements of an [`ArraySized`](#ArraySized) with an amount of elements in a range\nto the end of a given [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\n\n    import Linear exposing (Direction(..))\n\n    ArraySized.l3 1 2 3\n        |> ArraySized.attach Up (ArraySized.l3 4 5 6)\n        --: ArraySized number_ (In (Up6 minX_) (Up6 maxX_))\n        |> ArraySized.toList\n    --> [ 1, 2, 3, 4, 5, 6 ]\n\n    ArraySized.l3 1 2 3\n        |> ArraySized.attach Down (ArraySized.l3 4 5 6)\n        |> ArraySized.toList\n    --> [ 4, 5, 6, 1, 2, 3 ]\n\nDon't know both length maxima? → [`attachMin`](#attachMin)\n\n","type":"Linear.Direction -> ArraySized.ArraySized element (N.In (N.Up minPlusX N.To minSumPlusX) (N.Up maxPlusX N.To maxSumPlusX)) -> ArraySized.ArraySized element (N.In (N.Up minX N.To minPlusX) (N.Up maxX N.To maxPlusX)) -> ArraySized.ArraySized element (N.In (N.Up minX N.To minSumPlusX) (N.Up maxX N.To maxSumPlusX))"},{"name":"attachMin","comment":" Glue elements of an [`ArraySized`](#ArraySized)\nto the end of a given [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\n\n    ArraySized.l3 1 2 3\n        |> ArraySized.attachMin Up atLeast3Elements\n    --: ArraySized ... (Min (Up6 x_))\n\n    ArraySized.l3 1 2 3\n        |> ArraySized.attachMin Down atLeast3Elements\n    --: ArraySized ... (Min (Up6 x_))\n\nKnow both length maxima? → [`attach`](#attach)\n\n","type":"Linear.Direction -> ArraySized.ArraySized element (N.In (N.Up minPlusX N.To minSumPlusX) extensionMax_) -> ArraySized.ArraySized element (N.In (N.Up x N.To minPlusX) max_) -> ArraySized.ArraySized element (N.Min (N.Up x N.To minSumPlusX))"},{"name":"drop","comment":" Elements after a certain number of elements\nin a given [`Direction`](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\n\n    import Linear exposing (Direction(..))\n    import N exposing (n2)\n\n    ArraySized.l4 0 1 2 3\n        |> ArraySized.drop Down n2\n        --: ArraySized number_ (In (Up2 minX_) (Up2 maxX_))\n        |> ArraySized.toList\n    --> [ 0, 1 ]\n\n    between6And10Elements\n        |> ArraySized.drop Up between2And3\n        --: ArraySized number_ (In (Up3 minX_) (Up8 maxX_))\n\n  - Don't know its length maximum? → [`dropMin`](#dropMin)\n  - Can the dropped length's maximum be greater than its length's minimum?\n    → [`dropMax`](#dropMax)\n\n","type":"Linear.Direction -> N.N (N.In (N.Down maxPlusX N.To takenMaxPlusX) (N.Down min N.To takenMin)) -> ArraySized.ArraySized element (N.In (N.On min) (N.Up maxX N.To maxPlusX)) -> ArraySized.ArraySized element (N.In (N.On takenMin) (N.Up maxX N.To takenMaxPlusX))"},{"name":"dropMax","comment":" Elements after a certain number of elements\nin a given [`Direction`](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\n\n    import Linear exposing (Direction(..))\n    import N exposing (n2, n5)\n\n    ArraySized.l4 0 1 2 3\n        |> ArraySized.dropMax Down (3 |> N.intToIn ( n2, n5 ))\n        --: ArraySized number_ (In (Up0 minX_) (On N2))\n        |> ArraySized.toList\n    --> [ 0, 1 ]\n\n  - Is the dropped length's maximum less than its length's minimum? → [`drop`](#drop)\n  - Don't know the array's length maximum? → [`dropMin`](#dropMin)\n\n","type":"Linear.Direction -> N.N (N.In (N.Down max N.To differenceMax) toDropMax_) -> ArraySized.ArraySized element (N.In min_ (N.On max)) -> ArraySized.ArraySized element (N.In (N.Up0 minX_) (N.On differenceMax))"},{"name":"dropMin","comment":" Elements after a certain number of elements\nin a given [`Direction`](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\n\n    import Linear exposing (Direction(..))\n    import N exposing (n2)\n\n    atLeast6Elements\n        |> ArraySized.dropMin Down n2\n    --: ArraySized ... (Min (On N4))\n\n  - Know its length maximum? → [`drop`](#drop)\n  - Can the dropped length's maximum be greater than its length's minimum?\n    → [`dropMax`](#dropMax)\n\n","type":"Linear.Direction -> N.N (N.In droppedMin_ (N.Down min N.To takenMin)) -> ArraySized.ArraySized element (N.In (N.On min) max) -> ArraySized.ArraySized element (N.In (N.On takenMin) max)"},{"name":"element","comment":" Its element at a valid location\nin a given [`Direction`](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\n\nRemember that indexes are 1-indexed!\n\n    import Linear exposing (Direction(..))\n    import N exposing (n1, n2)\n\n    ArraySized.l4 0 1 2 3\n        |> ArraySized.element ( Up, n1 )\n    --> 0\n\n    ArraySized.l4 0 1 2 3\n        |> ArraySized.element ( Down, n2 )\n    --> 2\n\n","type":"( Linear.Direction, N.N (N.In (N.On (N.Add1 indexMin_)) (N.Up indexMaxToMin_ N.To min)) ) -> ArraySized.ArraySized element (N.In (N.On min) max_) -> element"},{"name":"elementAlter","comment":" Change the element at an index\nin a given [`Direction`](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\nbased on its previous value\n\n    import Linear exposing (Direction(..))\n    import N exposing (n0)\n\n    ArraySized.l3 1 20 30\n        |> ArraySized.elementAlter ( Up, n0 ) (\\x -> x * 10)\n        |> ArraySized.toList\n    --> [ 10, 20, 30 ]\n\n    ArraySized.l3 1 20 30\n        |> ArraySized.elementAlter ( Down, n0 ) negate\n        |> ArraySized.toList\n    --> [ 1, 20, -30 ]\n\nAn index that's too high to point to an existing element is ignored\nand no element is altered\n\n    import Linear exposing (Direction(..))\n    import N exposing (n3)\n\n    ArraySized.l3 1 20 30\n        |> ArraySized.elementAlter ( Up, n3 ) (\\x -> x * 10)\n        |> ArraySized.toList\n    --> [ 1, 20, 30 ]\n\n","type":"( Linear.Direction, N.N indexRange_ ) -> (element -> element) -> ArraySized.ArraySized element range -> ArraySized.ArraySized element range"},{"name":"elementReplace","comment":" Set the element at an index\nin a given [`Direction`](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\n\n    import Linear exposing (Direction(..))\n    import N exposing (n1, n2)\n\n    ArraySized.l3 \"I\" \"am\" \"ok\"\n        |> ArraySized.elementReplace ( Up, n2 )\n            (\\() -> \"confusion\")\n        |> ArraySized.toList\n    --> [ \"I\", \"am\", \"confusion\" ]\n\n    ArraySized.l3 \"I\" \"am\" \"ok\"\n        |> ArraySized.elementReplace ( Down, n1 )\n            (\\() -> \"feel\")\n        |> ArraySized.toList\n    --> [ \"I\", \"feel\", \"ok\" ]\n\nAn index that's too high to point to an existing element is ignored\nand no element is replaced\n\n    import Linear exposing (Direction(..))\n    import N exposing (n3)\n\n    ArraySized.l3 \"I\" \"am\" \"ok\"\n        |> ArraySized.elementReplace ( Down, n3 )\n            (\\() -> \"feel\")\n        |> ArraySized.toList\n    --> [ \"I\", \"am\", \"ok\" ]\n\n","type":"( Linear.Direction, N.N indexRange_ ) -> (() -> element) -> ArraySized.ArraySized element range -> ArraySized.ArraySized element range"},{"name":"elementTry","comment":" Its element at a given location\nin a given [`Direction`](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/).\nBecause the index doesn't promise it's `<=` the [`ArraySized`](#ArraySized)'s length minimum,\n`elementTry` gives back an `Emptiable`\n\nUse [`element`](#element) if you know your index always points to a valid location\n\n    import Linear exposing (Direction(..))\n    import Emptiable\n    import N exposing (n1, n5)\n\n    ArraySized.l4 0 1 2 3\n        |> ArraySized.elementTry ( Up, n5 )\n    --> Emptiable.empty\n\n    ArraySized.l4 0 1 2 3\n        |> ArraySized.elementTry ( Down, n1 )\n    --> Emptiable.filled 3\n\n","type":"( Linear.Direction, N.N indexRange_ ) -> ArraySized.ArraySized element range_ -> Emptiable.Emptiable element Possibly.Possibly"},{"name":"empty","comment":" No elements\n\n    ArraySized.empty\n    --: ArraySized element_ (In (Up0 minX_) (Up0 maxX_))\n        |> ArraySized.push \":)\"\n        --: ArraySized String (In (Up1 minX_) (Up1 maxX_))\n\n","type":"ArraySized.ArraySized element_ (N.In (N.Up0 minX_) (N.Up0 maxX_))"},{"name":"fills","comment":" Take every `filled` value, drop every `empty`\n\n    import Emptiable exposing (filled)\n\n    ArraySized.l3 (\"This\" |> filled) Emptiable.empty (\"fine\" |> filled)\n        |> ArraySized.fills\n        --: ArraySized String (In (Up0 minX_) (Up3 maxX_))\n        |> ArraySized.toList\n    --> [ \"This\", \"fine\" ]\n\nUse [`map |> fills` to get the same functionality as \"filterMap\"](https://github.com/lue-bird/elm-typesafe-array/blob/master/Q%20%26%20A.md#no-filtermap-only-fills)\n\n    import Emptiable\n\n    ArraySized.l3 \"1.2\" \"2\" \"hello\"\n        |> ArraySized.map (String.toInt >> Emptiable.fromMaybe)\n        |> ArraySized.fills\n        |> ArraySized.toList\n    --> [ 2 ]\n\n","type":"ArraySized.ArraySized (Emptiable.Emptiable fill possiblyOrNever_) (N.In min_ max) -> ArraySized.ArraySized fill (N.In (N.Up0 minX_) max)"},{"name":"fold","comment":" A fold in a given [`Direction`](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\nwhere the initial result is the first element in the [`ArraySized`](#ArraySized)\n\n    import Linear exposing (Direction(..))\n\n    ArraySized.l3 234 345 543\n        |> ArraySized.fold Up Basics.max\n    --> 543\n\n    ArraySized.l3 \"go\" \"to\" \"uni\"\n        |> ArraySized.fold Down\n            (\\word soFar -> soFar ++ \" \" ++ word)\n    --> \"uni to go\"\n\n","type":"Linear.Direction -> (element -> element -> element) -> ArraySized.ArraySized element (N.In (N.On (N.Add1 minFrom1_)) max_) -> element"},{"name":"foldFrom","comment":" Reduce an `ArraySized` in a given [`Direction`](https://package.elm-lang.org/packages/indique/elm-linear-direction/latest/)\n\n    import Linear exposing (Direction(..))\n\n    ArraySized.l4 'l' 'i' 'v' 'e'\n        |> ArraySized.foldFrom \"\" Down String.cons\n    --> \"live\"\n\n    ArraySized.l4 'l' 'i' 'v' 'e'\n        |> ArraySized.foldFrom \"\" Up String.cons\n    --> \"evil\"\n\n    sum =\n        ArraySized.foldFrom 0 Up (\\soFar n -> soFar + n)\n\n    product =\n        ArraySized.foldFrom 0 Up (\\soFar n -> soFar * n)\n\n","type":"result -> Linear.Direction -> (element -> result -> result) -> ArraySized.ArraySized element range_ -> result"},{"name":"foldFromOne","comment":" Fold, starting from one end element transformed to the initial accumulation value,\nthen reducing what's accumulated in a given [`Direction`](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\nUsually used to convert to a different non-empty structure\n\n    import Emptiable exposing (Emptiable)\n    import N exposing (Add1, In, On)\n    import Stack exposing (Stacked)\n\n    toStackFilled :\n        ArraySized\n            element\n            (In (On (Add1 minFrom1_)) max_)\n        -> Emptiable (Stacked element) Never\n    toStackFilled =\n        ArraySized.foldFromOne Stack.one Stack.onTopLay\n\n[`fold`](#fold) is a simple version that folds directly from the start element:\n\n    Stack.fold =\n        Stack.foldFromOne identity\n\n","type":"(element -> folded) -> Linear.Direction -> (element -> folded -> folded) -> ArraySized.ArraySized element (N.In (N.On (N.Add1 minFrom1_)) max_) -> folded"},{"name":"fromArray","comment":" Create from an `Array`.\nAs every `Array` has `>= 0` elements\n\n    arrayFromSomeOtherLibrary |> ArraySized.fromArray\n    --: ArraySized ... (Min (Up0 x_))\n\nDon't use it for construction\n\n    ArraySized.fromArray\n        (Array.fromList [ 0, 1, 2, 3, 4, 5, 6 ])\n    -- big no\n\nMake sure the compiler knows as much as you about the amount of elements!\n\n    ArraySized.l7 0 1 2 3 4 5 6 -- ok\n\n    ArraySized.n1To n6 -- big yes\n\n[\"wrap early, unwrap late\"](https://elm-radio.com/episode/wrap-early-unwrap-late)\n\n","type":"Array.Array element -> ArraySized.ArraySized element (N.Min (N.Up0 x_))"},{"name":"fromEmptiable","comment":" On `Emptiable.filled` [`ArraySized.one`](#one),\non `Emptiable.empty` [`ArraySized.empty`](#empty)\n\n    import N exposing (n0)\n    import Emptiable exposing (filled)\n\n    filled \"hi\"\n        |> ArraySized.fromEmptiable\n        --: ArraySized ... (In (Up0 minX_) (Up1 maxX_))\n        |> ArraySized.toList\n    --> [ \"hi\" ]\n\n    Emptiable.empty\n        |> ArraySized.fromEmptiable\n        --: ArraySized ... (In (Up0 minX_) (Up1 maxX_))\n        |> ArraySized.toList\n    --> []\n\nEmptiness knowledge `possiblyOrNever` is transferred\n\n","type":"Emptiable.Emptiable element possiblyOrNever -> ArraySized.ArraySized element (N.In (N.On (N.N0OrAdd1 possiblyOrNever N.N0)) (N.Up1 maxX_))"},{"name":"fromList","comment":" Create from a `List`.\nAs every `List` has `>= 0` elements\n\n    listFromSomeOtherLibrary |> ArraySized.fromList\n    --: ArraySized ... (Min (Up0 x_))\n\nDon't use for construction\n\n    ArraySized.fromList [ 0, 1, 2, 3, 4, 5, 6 ]\n    -- big no!\n\nMake sure the compiler knows as much as you about the amount of elements!\n\n    ArraySized.l7 0 1 2 3 4 5 6 -- ok\n\n    ArraySized.n1To n6 -- big yes\n\n[\"wrap early, unwrap late\"](https://elm-radio.com/episode/wrap-early-unwrap-late)\n\n","type":"List.List element -> ArraySized.ArraySized element (N.Min (N.Up0 minX_))"},{"name":"fromStack","comment":" Create from a stack.\nAs every stack has `>= 0` elements\n\n    Emptiable.empty |> ArraySized.fromStack\n    --: ArraySized ... (Min (On N0))\n\n    Stack.topBelow '#' [] |> ArraySized.fromStack\n    --: ArraySized Char (Min (On N1))\n\nDon't use for construction\n\n    ArraySized.fromStackEmptiable\n        (Stack.fromList [ 0, 1, 2, 3, 4, 5, 6 ])\n    -- big no!\n\nMake sure the compiler knows as much as you about the amount of elements!\n\n    ArraySized.l7 0 1 2 3 4 5 6 -- ok\n\n    ArraySized.n1To n6 -- big yes\n\n[\"wrap early, unwrap late\"](https://elm-radio.com/episode/wrap-early-unwrap-late)\n\n","type":"Emptiable.Emptiable (Stack.Stacked element) possiblyOrNever -> ArraySized.ArraySized element (N.Min (N.On (N.N0OrAdd1 possiblyOrNever N.N0)))"},{"name":"fromString","comment":" Create from the `Char`s of a `String`.\nAs every `String` has `>= 0` elements\n\n    stringFromSomeOtherLibrary |> ArraySized.fromString\n    --: ArraySized Char (Min (Up0 minX_))\n\nTry not to use this for construction\nand instead use the safe versions like `l<n>`\n\n","type":"String.String -> ArraySized.ArraySized Char.Char (N.Min (N.Up0 minX_))"},{"name":"fuzz","comment":" `Fuzzer` for an [`ArraySized`](#ArraySized) with a given length\n\n    import N exposing (n3)\n    import Fuzz\n\n    ArraySized.fuzz Fuzz.bool n3\n        |> Fuzz.map ArraySized.toList\n        --: Fuzzer (ArraySized Bool (In (Up3 minX_) (Up6 maxX_)))\n        |> Fuzz.examples 3\n    --> [ [ False, True, False ]\n    --> , [ False, False, False ]\n    --> , [ False, False, True ]\n    --> ]\n\nTo fuzz an [`ArraySized`](#ArraySized) with a length in a range, [`inFuzz`](#inFuzz)\n\n","type":"Fuzz.Fuzzer element -> N.N range -> Fuzz.Fuzzer (ArraySized.ArraySized element range)"},{"name":"has","comment":" Compare its length to a given exact length. Does it match or is it `BelowOrAbove`?\n\n    import N exposing (n7)\n\n    chooseFormation :\n        ArraySized Character (In min N50)\n        -> Formation\n    chooseFormation characters =\n        case characters |> ArraySized.has n7 of\n            Ok exactly7 ->\n                SpecialAttack exactly7\n\n            Err (N.Below l6AtLeast) ->\n                Retreat l6AtLeast\n\n            Err (N.Above l8AtLeast) ->\n                Fight l8AtLeast\n\n","type":"N.N (N.In (N.Up minX N.To (N.Add1 comparedAgainstMinPlusXFrom1)) (N.Up maxX N.To (N.Add1 comparedAgainstMaxPlusXFrom1))) -> ArraySized.ArraySized element (N.In min max) -> Result.Result (N.BelowOrAbove (ArraySized.ArraySized element (N.In min (N.Up maxX N.To comparedAgainstMaxPlusXFrom1))) (ArraySized.ArraySized element (N.In (N.Up minX N.To (N.Add2 comparedAgainstMinPlusXFrom1)) max))) (ArraySized.ArraySized element (N.In (N.Up minX N.To (N.Add1 comparedAgainstMinPlusXFrom1)) (N.Up maxX N.To (N.Add1 comparedAgainstMaxPlusXFrom1))))"},{"name":"hasAtLeast","comment":" Is its length below (`Err`) or at least as big as (`Ok`) a given `N`?\n\n    import N exposing (n5)\n\n    atLeast5 :\n        ArraySized element (In minLength_ max)\n        -> Maybe (element ArraySized (In (Up5 minX_) max))\n    atLeast5 =\n        ArraySized.hasAtLeast n5\n            >> Result.toMaybe\n\n","type":"N.N (N.In lowerLimitMin (N.Up lowerLimitMaxX N.To (N.Add1 lowerLimitMaxFrom1PlusX))) -> ArraySized.ArraySized element (N.In min max) -> Result.Result (ArraySized.ArraySized element (N.In min (N.Up lowerLimitMaxX N.To lowerLimitMaxFrom1PlusX))) (ArraySized.ArraySized element (N.In lowerLimitMin max))"},{"name":"hasAtLeast1","comment":" Transfer the knowledge about whether 0 is a possible length\n\n    toEmptiable :\n        ArraySized\n            element\n            (In (On (N0OrAdd1 possiblyOrNever minFrom1_)) (Up maxTo1_ To N1))\n        -> Emptiable element possiblyOrNever\n    toEmptiable =\n        \\arraySized ->\n            arraySized\n                |> ArraySized.hasAtLeast1\n                |> Emptiable.map ArraySized.toOne\n\nIt really is just that simple: first try [`hasAtLeast1`](#hasAtLeast1),\nthen map that possibility using the knowledge that the [`ArraySized`](#ArraySized)\nhas at least 1 element\n\n    toStack :\n        ArraySized\n            element\n            (In (On (N0OrAdd1 possiblyOrNever minFrom1_)) max_)\n        -> Emptiable (Stacked element) possiblyOrNever\n    toStack =\n        \\arraySized ->\n            arraySized\n                |> ArraySized.hasAtLeast1\n                |> Emptiable.mapFlat\n                    (ArraySized.foldFromOne Stack.one Down Stack.onTopLay)\n\n","type":"ArraySized.ArraySized element (N.In (N.On (N.N0OrAdd1 possiblyOrNever minFrom1_)) max) -> Emptiable.Emptiable (ArraySized.ArraySized element (N.In (N.Up1 minX_) max)) possiblyOrNever"},{"name":"hasAtMost","comment":" Is its length atMost (`Ok`) or above (`Err`) a given length?\n\n    -- at least 3 and only up to 50 tags\n    tag :\n        ArraySized\n            String\n            (In (On (Add3 minFrom3_)) (Up maxTo50_ To N50))\n        -> (Metadata -> MetadataTagged)\n\n    tagIfValidTags :\n        ArraySized String (In (On (Add3 minFrom3_)) max_)\n        -> (Metadata -> Maybe MetadataTagged)\n    tagIfValidTags tags =\n        case tags |> ArraySized.hasAtMost n50 of\n            Ok atMost50 ->\n                tag atMost50 >> Just\n\n            Err _ ->\n                \\_ -> Nothing\n\n","type":"N.N (N.In (N.Up upperLimitMinX N.To upperLimitMinPlusX) upperLimitMax) -> ArraySized.ArraySized element (N.In min max) -> Result.Result (ArraySized.ArraySized element (N.In (N.Up upperLimitMinX N.To (N.Add1 upperLimitMinPlusX)) max)) (ArraySized.ArraySized element (N.In min upperLimitMax))"},{"name":"hasIn","comment":" Compared to a range from a lower to an upper bound, is its length in, `BelowOrAbove` range?\n\n    import N exposing (n10, n16)\n\n    chooseFormation :\n        ArraySized Character (In minLength_ N50)\n        -> Formation\n    chooseFormation characters =\n        case characters |> ArraySized.hasIn ( n10, n16 ) of\n            Ok between10And16 ->\n                SpecialAttack between10And16\n\n            Err (N.Below n9AtMost) ->\n                Retreat n9AtMost\n\n            Err (N.Above n17AtLeast) ->\n                Fight n17AtLeast\n\n","type":"( N.N (N.In lowerLimitMin (N.Up lowerLimitMaxX N.To (N.Add1 lowerLimitMaxPlusXFrom1))), N.N (N.In (N.Up upperLimitMinX N.To upperLimitMinPlusX) upperLimitMax) ) -> ArraySized.ArraySized element (N.In min max) -> Result.Result (N.BelowOrAbove (ArraySized.ArraySized element (N.In min (N.Up lowerLimitMaxX N.To lowerLimitMaxPlusXFrom1))) (ArraySized.ArraySized element (N.In (N.Up upperLimitMinX N.To (N.Add1 upperLimitMinPlusX)) max))) (ArraySized.ArraySized element (N.In lowerLimitMin upperLimitMax))"},{"name":"inFuzz","comment":" `Fuzzer` for an [`ArraySized`](#ArraySized) with a length in a given range.\nFor larger ranges, smaller lengths are preferred\n\n    import N exposing (n3, n6)\n    import Fuzz\n\n    ArraySized.inFuzz Fuzz.bool ( n3, n6 )\n        |> Fuzz.map ArraySized.toList\n        --: Fuzzer (ArraySized Bool (In (Up3 minX_) (Up6 maxX_)))\n        |> Fuzz.examples 3\n    --> [ [ False, True, False, False, True, True ]\n    --> , [ False, False, False, True ]\n    --> , [ False, True, False, False, False, False ]\n    --> ]\n\n","type":"Fuzz.Fuzzer element -> ( N.N (N.In lowerLimitMin (N.Up lowerLimitMaxToUpperLimitMin_ N.To upperLimitMin)), N.N (N.In (N.On upperLimitMin) upperLimitMax) ) -> Fuzz.Fuzzer (ArraySized.ArraySized element (N.In lowerLimitMin upperLimitMax))"},{"name":"inToNumber","comment":" [`ArraySized`](#ArraySized) with a [`length`](#length)\nof [`On` range](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#InOn)\n→ equatable [`OnValue` range](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#InOnValue)\n\nIf you have a `Min` length, you instead only need [`minToNumber`](#minToNumber)\n\n","type":"ArraySized.ArraySized element (N.In (N.On min) (N.On max)) -> ArraySized.ArraySized element (N.In min max)"},{"name":"inToOn","comment":" [`ArraySized`](#ArraySized) with a [`length`](#length)\nof equatable [`OnValue` range](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#InOnValue)\n→ [On range](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#InOn),\nallowing it to be [altered](#alter), [compared](#observe-length), ...\n\nIf you have a `Min` length, you instead only need [`minToOn`](#minToOn)\n\n","type":"ArraySized.ArraySized element (N.In min max) -> ArraySized.ArraySized element (N.In (N.On min) (N.On max))"},{"name":"insert","comment":" Put an element in the `ArraySized` at a given index\nin a given [`Direction`](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\n\nRemember that indexes are 1-indexed!\n\n    import Linear exposing (Direction(..))\n    import N exposing (n2, n3)\n\n    ArraySized.l3 'a' 'c' 'd'\n        |> ArraySized.insert ( Up, n2 ) 'b'\n        --: ArraySized Char (In (On N4) (Up4 maxX_))\n        |> ArraySized.toList\n    --> [ 'a', 'b', 'c', 'd' ]\n\n    ArraySized.l3 'a' 'c' 'd'\n        |> ArraySized.insert ( Down, n3 ) 'b'\n        |> ArraySized.toList\n    --> [ 'a', 'b', 'c', 'd' ]\n\n[`insertMin`](#insertMin) if you don't know the length maximum\n\nNeed the length minimum to not become `On`\n(for results etc.) → [`|> minTo`](#minTo)\n\n","type":"( Linear.Direction, N.N (N.In (N.On (N.Add1 indexMinFrom1_)) (N.Up indexMaxToMin_ N.To (N.Add1 min))) ) -> element -> ArraySized.ArraySized element (N.In (N.On min) (N.Up maxX N.To maxPlusX)) -> ArraySized.ArraySized element (N.In (N.On (N.Add1 min)) (N.Up maxX N.To (N.Add1 maxPlusX)))"},{"name":"insertMin","comment":" Put a new element at an index\nin a given [`Direction`](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\n\n    import Linear exposing (Direction(..))\n    import N exposing (n0, n1)\n\n    atLeast5Elements\n        |> ArraySized.insertMin ( Down, n1 ) \"before last\"\n        --: ArraySized String (Min (On N6))\n\n    minCons :\n        element\n        -> ArraySized element (In (On min) max_)\n        -> ArraySized element (Min (On (Add1 min)))\n    minCons =\n        ArraySized.insertMin ( Up, n0 )\n\n[`insert`](#insert) if you know the length maximum\n\nNeed the length minimum to not become `On`\n(for results etc.) → [`|> minTo`](#minTo)\n\n","type":"( Linear.Direction, N.N (N.In (N.On (N.Add1 indexMinFrom1_)) (N.Up indexMaxToMin_ N.To (N.Add1 min))) ) -> element -> ArraySized.ArraySized element (N.In (N.On min) max_) -> ArraySized.ArraySized element (N.Min (N.On (N.Add1 min)))"},{"name":"interweave","comment":" Place all elements of an [`ArraySized`](#ArraySized)\nbetween all current members.\nExtra elements of either [`ArraySized`](#ArraySized) are attached to the end\nwithout separating elements from the other [`ArraySized`](#ArraySized)\n\n    import N exposing (n2)\n\n    ArraySized.l3 \"turtles\" \"turtles\" \"turtles\"\n        |> ArraySized.interweave (ArraySized.repeat \"on\" n2)\n        --: ArraySized String (In (Up5 minX_) (Up5 maxX_))\n        |> ArraySized.toList\n    --> [ \"turtles\", \"on\", \"turtles\", \"on\", \"turtles\" ]\n\n    ArraySized.l3 \"turtles\" \"turtles\" \"turtles\"\n        |> ArraySized.interweave (ArraySized.repeat \"on\" between5And10)\n    --→ \"turtles\" \"on\" \"turtles\" \"on\" \"turtles\" \"on\" \"on\" \"on\" ...\n    --: ArraySized String (In (Up5 minX_) (Up13 maxX_))\n\nDon't know both maxima → [`interweaveMin`](#interweaveMin)\n\n","type":"ArraySized.ArraySized element (N.In (N.Up minPlusX N.To minSumPlusX) (N.Up maxPlusX N.To maxSumPlusX)) -> ArraySized.ArraySized element (N.In (N.Up x N.To minPlusX) (N.Up x N.To maxPlusX)) -> ArraySized.ArraySized element (N.In (N.Up x N.To minSumPlusX) (N.Up x N.To maxSumPlusX))"},{"name":"interweaveMin","comment":" Place all elements of an [`ArraySized`](#ArraySized)\nbetween all current members.\nExtra elements of either [`ArraySized`](#ArraySized) are attached to the end\nwithout separating elements from the other [`ArraySized`](#ArraySized)\n\n    import N exposing (n2)\n\n    ArraySized.l3 \"turtles\" \"turtles\" \"turtles\"\n        |> ArraySized.interweaveMin\n            (ArraySized.repeat \"on\" atLeast2)\n        --: ArraySized String (Min (Up5 minX_))\n\nKnow both maxima → [`interweave`](#interweave)\n\n","type":"ArraySized.ArraySized element (N.In (N.Up minPlusX N.To minSumPlusX) interweaveMax_) -> ArraySized.ArraySized element (N.In (N.Up x N.To minPlusX) max_) -> ArraySized.ArraySized element (N.Min (N.Up x N.To minSumPlusX))"},{"name":"l10","comment":" Create with 10 given elements in the order they are supplied\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> ArraySized.ArraySized element (N.In (N.Up10 minX_) (N.Up10 maxX_))"},{"name":"l11","comment":" Create with 11 given elements in the order they are supplied\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> ArraySized.ArraySized element (N.In (N.Up11 minX_) (N.Up11 maxX_))"},{"name":"l12","comment":" Create with 12 given elements in the order they are supplied\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> ArraySized.ArraySized element (N.In (N.Up12 minX_) (N.Up12 maxX_))"},{"name":"l13","comment":" Create with 13 given elements in the order they are supplied\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> ArraySized.ArraySized element (N.In (N.Up13 minX_) (N.Up13 maxX_))"},{"name":"l14","comment":" Create with 14 given elements in the order they are supplied\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> ArraySized.ArraySized element (N.In (N.Up14 minX_) (N.Up14 maxX_))"},{"name":"l15","comment":" Create with 15 given elements in the order they are supplied\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> ArraySized.ArraySized element (N.In (N.Up15 minX_) (N.Up15 maxX_))"},{"name":"l16","comment":" Create with 16 given elements in the order they are supplied\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> ArraySized.ArraySized element (N.In (N.Up16 minX_) (N.Up16 maxX_))"},{"name":"l2","comment":" Create with 2 given elements in the order they are supplied\n","type":"element -> element -> ArraySized.ArraySized element (N.In (N.Up2 minX_) (N.Up2 maxX_))"},{"name":"l3","comment":" Create with 3 given elements in the order they are supplied\n","type":"element -> element -> element -> ArraySized.ArraySized element (N.In (N.Up3 minX_) (N.Up3 maxX_))"},{"name":"l4","comment":" Create with 4 given elements in the order they are supplied\n","type":"element -> element -> element -> element -> ArraySized.ArraySized element (N.In (N.Up4 minX_) (N.Up4 maxX_))"},{"name":"l5","comment":" Create with 5 given elements in the order they are supplied\n","type":"element -> element -> element -> element -> element -> ArraySized.ArraySized element (N.In (N.Up5 minX_) (N.Up5 maxX_))"},{"name":"l6","comment":" Create with 6 given elements in the order they are supplied\n","type":"element -> element -> element -> element -> element -> element -> ArraySized.ArraySized element (N.In (N.Up6 minX_) (N.Up6 maxX_))"},{"name":"l7","comment":" Create with 7 given elements in the order they are supplied\n","type":"element -> element -> element -> element -> element -> element -> element -> ArraySized.ArraySized element (N.In (N.Up7 minX_) (N.Up7 maxX_))"},{"name":"l8","comment":" Create with 8 given elements in the order they are supplied\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> ArraySized.ArraySized element (N.In (N.Up8 minX_) (N.Up8 maxX_))"},{"name":"l9","comment":" Create with 9 given elements in the order they are supplied\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> ArraySized.ArraySized element (N.In (N.Up9 minX_) (N.Up9 maxX_))"},{"name":"length","comment":" Its amount of elements\n\n    import N exposing (n3)\n\n    ArraySized.l3 1 2 3\n        |> ArraySized.length\n        --: N (In (Up3 minX_) (Up3 maxX_))\n        |> N.toInt\n    --> 3\n\n    between3And5Elements |> ArraySized.length\n    --: N (In (Up3 minX_) (Up5 maxX_))\n\n    atLeast3Elements |> ArraySized.length\n    --: N (Min (Up3 minX_))\n\n","type":"ArraySized.ArraySized element_ range -> N.N range"},{"name":"map","comment":" Change all elements based on their current values\n\n    import N exposing (n25)\n\n    aToZ : ArraySized Char (In N26 (N26Plus a_))\n    aToZ =\n        ArraySized.n1To n25\n            |> ArraySized.map inABC\n\n    inABC index =\n        ('a' |> Char.toCode)\n            + (index |> N.toInt)\n            |> Char.fromCode\n\nOh look, more type-safety!\n\n","type":"(element -> mappedElement) -> ArraySized.ArraySized element range -> ArraySized.ArraySized mappedElement range"},{"name":"mapFoldFrom","comment":" Map each element using information collected from previous steps,\nfolding in a given [`Direction`](https://dark.elm.dmy.fr/packages/lue-bird/elm-linear-direction/latest/)\nfrom given initial information.\n\nBoth the mapped [`ArraySized`](#ArraySized) and the folded information will be returned\n\nYou'll often find this under the name \"mapAccum\"\n\n    import Linear exposing (Direction(..))\n\n    ArraySized.l3 1 2 3\n        |> ArraySized.mapFoldFrom 0\n            Down\n            (\\state ->\n                { element = state.folded\n                , folded = state.folded + state.element\n                }\n            )\n    --→ { mapped = ArraySized.l3 5 3 0, folded = 6 }\n\n    mapIndexed : Direction -> (Int -> a -> b) -> (ArraySized a l -> ArraySized b l)\n    mapIndexed indexDirection mapAtIndex =\n        ArraySized.mapFoldFrom 0\n            indexDirection\n            (\\state ->\n                { element = state.element |> mapAtIndex state.folded\n                , folded = state.folded + 1\n                }\n            )\n            >> .mapped\n\n    ArraySized.l4 'h' 'i' 'y' 'o'\n        |> mapIndexed Up Tuple.pair\n    --→ ArraySized.l4 ( 0, 'h' ) ( 1, 'i' ) ( 2, 'y' ) ( 3, 'o' )\n\n    ArraySized.l4 'h' 'i' 'y' 'o'\n        |> mapIndexed Down Tuple.pair\n    --→ ArraySized.l4 ( 3, 'h' ) ( 2, 'i' ) ( 1, 'y' ) ( 0, 'o' )\n\n","type":"folded -> Linear.Direction -> ({ element : element, folded : folded } -> { element : mappedElement, folded : folded }) -> ArraySized.ArraySized element range -> { mapped : ArraySized.ArraySized mappedElement range, folded : folded }"},{"name":"maxAdd","comment":" Have a specific maximum in mind? → [`maxTo`](#maxTo)\n\nWant to increase the upper bound by a on amount? ↓\n\n    ArraySized.l4 'a' 'b' 'c' 'd'\n        --: ArraySized Char (In (Up4 minX_) (Up4 maxX_))\n        |> ArraySized.maxAdd n2\n    --: ArraySized Char (In (Up4 minX_) (Up6 maxX_))\n\nWhen is this useful? Very rarely, to preserve type variables\n\n    emptiablePush :\n        Emptiable element possiblyOrNever_\n        ->\n            (ArraySized\n                element\n                (In\n                    (Up minX To minPlusX)\n                    (Up maxX To maxPlusX)\n                )\n             ->\n                ArraySized\n                    element\n                    (In (Up minX To minPlusX) (Up maxX To (Add1 maxPlusX)))\n            )\n    emptiablePush emptiableElementToPush =\n        case emptiableElementToPush of\n            Emptiable.Empty _ ->\n                ArraySized.maxAdd n1\n\n            Emptiable.Filled elementToPush ->\n                ArraySized.push elementToPush\n                    >> ArraySized.minSubtract n1\n\nHere, you could alternatively [`attach`](#attach) its [`fromEmptiable`](#fromEmptiable).\n\nMore in [`N.maxAdd`](https://dark.elm.dmy.fr/packages/lue-bird/elm-bounded-nat/latest/N#maxAdd)\n\n","type":"N.N (N.In maxIncreaseMin_ (N.Up maxPlusX N.To maxIncreasedPlusX)) -> ArraySized.ArraySized element (N.In min (N.Up x N.To maxPlusX)) -> ArraySized.ArraySized element (N.In min (N.Up x N.To maxIncreasedPlusX))"},{"name":"maxEndsSubtract","comment":" Decrease the start and end of its [length](#length) maximum\n[difference](https://dark.elm.dmy.fr/packages/lue-bird/elm-bounded-nat/latest/N#Up)\n\n    ArraySized.repeat () n3\n        --: ArraySized () (In (Up3 minX_) (Up3 (Add2 maxX_)))\n        |> ArraySized.maxEndsSubtract n2\n    --: ArraySized () (In (Up5 minX_) (Up5 maxX_))\n\n[`N.maxEndsSubtract`](https://dark.elm.dmy.fr/packages/lue-bird/elm-bounded-nat/latest/N#maxEndsSubtract)\nhas an example of where this can be useful.\n\n","type":"N.N (N.In (N.Down maxPlusX N.To maxPlusXDecreased) (N.Down maxX N.To maxXDecreased)) -> ArraySized.ArraySized element (N.In min (N.Up maxX N.To maxPlusX)) -> ArraySized.ArraySized element (N.In min (N.Up maxXDecreased N.To maxPlusXDecreased))"},{"name":"maxTo","comment":" Make an `ArraySized` with a on maximum length fit into functions with require a higher maximum length\n\n    type alias Row =\n        ArraySized Field (Exactly (On N18))\n\n`Row`'s length range can't be added to another length\n\n    attach2TemporaryFields : Row -> ...\n    attach2TemporaryFields rowFromModelOrSomeStorage =\n        ArraySized.repeat Temporary n2\n            |> ArraySized.attach Up rowFromModelOrSomeStorage\n\nOnly `Up<n> x` can do that\n\n    attach2TemporaryFields :\n        Row\n        ->\n            ArraySized\n                Field\n                (In (Up20 minX_) (Up20 maxX_))\n    attach2TemporaryFields rowFromModelOrSomeStorage =\n        ArraySized.repeat Temporary n2\n            |> ArraySized.attach Up\n                (rowFromModelOrSomeStorage\n                    |> ArraySized.minTo n18\n                    |> ArraySized.maxTo n18\n                )\n\nAnother example: re-enabling an argument's maximum difference\n\n    atMost18Elements : ArraySized ... (In min_ (Up maxTo18_ To N18))\n\nThe argument in `atMost18Elements` should also fit in `atMost19Elements` for example\n\n    atMost19Elements theArgument -- error\n\n    atMost19Elements (theArgument |> ArraySized.maxTo n19)\n\n[`maxAdd n1`](#maxAdd) is also possible,\nbut unless you want to preserve the `maxTo18_` type variable,\nthere's no need to not use this absolute operation\n\n","type":"N.N (N.In (N.On maxNewMin) maxNew) -> ArraySized.ArraySized element (N.In min (N.Up maxToMaxNewMin_ N.To maxNewMin)) -> ArraySized.ArraySized element (N.In min maxNew)"},{"name":"maxToInfinity","comment":" Convert the `ArraySized (In min ...)` to a `ArraySized (Min min)`\n\n    between4And10Elements |> ArraySized.maxToInfinity\n    --: ArraySized ... (Min (Up4 x_))\n\nThere is only 1 situation you should use this\n\nTo make these the same type\n\n    [ atLeast1Element, between1And10Elements ]\n\nElm complains\n\n> all the previous elements in the list are\n> `ArraySized ... (Min N1)`\n\n    [ atLeast1Element\n    , between1And10Elements |> ArraySized.maxToInfinity\n    ]\n\n","type":"ArraySized.ArraySized element (N.In min max_) -> ArraySized.ArraySized element (N.Min min)"},{"name":"maxToNumber","comment":" [`ArraySized`](#ArraySized) with a [`length`](#length)\nwith an [`On`](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#InOnValue) maximum\n→ equatable [`OnValue`](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#OnValue) maximum\n","type":"ArraySized.ArraySized element (N.In min (N.On max)) -> ArraySized.ArraySized element (N.In min max)"},{"name":"maxToOn","comment":" [`ArraySized`](#ArraySized) with a [`length`](#length)\nwith an equatable [`OnValue`](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#OnValue) maximum\n→ [`On`](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#On) maximum,\nallowing it to be [altered](#alter), [compared](#observe-length), ...\n","type":"ArraySized.ArraySized element (N.In min max) -> ArraySized.ArraySized element (N.In min (N.On max))"},{"name":"min0Adapt","comment":" Change the `possiblyOrNever` type for the case that its length minimum is 0\n\n`never` allows you to adapt any variable,\n`\\_ -> yourVariablePossiblyOrNever` swaps it for your given variable\n\n    fromEmptiable :\n        Emptiable element possiblyOrNever\n        ->\n            ArraySized\n                element\n                (In (On (N0OrAdd1 possiblyOrNever N0)) (Up1 maxX_))\n    fromEmptiable =\n        \\emptiable ->\n            case emptiable of\n                Emptiable.Filled content ->\n                    ArraySized.one content\n                        -- min = 0 can never happen → any variable possible\n                        |> ArraySized.min0Adapt never\n\n                Emptiable.Empty possiblyOrNever ->\n                    ArraySized.empty\n                        |> ArraySized.min0Adapt (\\_ -> possiblyOrNever)\n                        -- there's no min successor → any variable possible\n                        |> ArraySized.minAtLeast1Never\n                        -- the other has max = 1. Let's adapt that higher max here\n                        |> ArraySized.maxAdd n1\n\nusing [`minAtLeast1Never`](#minAtLeast1Never), [`maxAdd`](#maxAdd)\n\nRead more at [`N.min0Adapt`](https://dark.elm.dmy.fr/packages/lue-bird/elm-bounded-nat/latest/N#min0Adapt)\n\n","type":"(possiblyOrNever -> adaptedPossiblyOrNever) -> ArraySized.ArraySized element (N.In (N.On (N.N0OrAdd1 possiblyOrNever minFrom1)) max) -> ArraySized.ArraySized element (N.In (N.On (N.N0OrAdd1 adaptedPossiblyOrNever minFrom1)) max)"},{"name":"minAtLeast1Never","comment":" Change the successor type for the case that its length minimum is 1 + ...\nto allow adapting any variable\n\n    fromEmptiable :\n        Emptiable element possiblyOrNever\n        ->\n            ArraySized\n                element\n                (In (On (N0OrAdd1 possiblyOrNever N0)) (Up1 maxX_))\n    fromEmptiable =\n        \\emptiable ->\n            case emptiable of\n                Emptiable.Filled content ->\n                    ArraySized.one content\n                        -- min = 0 can never happen → any variable possible\n                        |> ArraySized.min0Adapt never\n\n                Emptiable.Empty possiblyOrNever ->\n                    ArraySized.empty\n                        |> ArraySized.min0Adapt (\\_ -> possiblyOrNever)\n                        -- there's no min successor → any variable possible\n                        |> ArraySized.minAtLeast1Never\n                        -- the other has max = 1. Let's adapt that higher max here\n                        |> ArraySized.maxAdd n1\n\nusing [`hasAtLeast1`](#hasAtLeast1), [`min0Adapt`](#min0Adapt).\n\n","type":"ArraySized.ArraySized element (N.In (N.On (N.N0OrAdd1 possiblyOrNever Basics.Never)) max) -> ArraySized.ArraySized element (N.In (N.On (N.N0OrAdd1 possiblyOrNever minFrom1_)) max)"},{"name":"minEndsSubtract","comment":" Decrease the start and end of its [length](#length) minimum\n[difference](https://dark.elm.dmy.fr/packages/lue-bird/elm-bounded-nat/latest/N#Up)\n\n    ArraySized.repeat () n3\n        --: ArraySized () (In (Up3 (Add2 minX_)) (Up3 maxX_))\n        |> ArraySized.minEndsSubtract n2\n    --: ArraySized () (In (Up5 minX_) (Up5 maxX_))\n\n[`N.maxEndsSubtract`](https://dark.elm.dmy.fr/packages/lue-bird/elm-bounded-nat/latest/N#maxEndsSubtract)\nhas an example of where this can be useful.\n\n","type":"N.N (N.In (N.Down minX N.To minXDecreased) (N.Down minPlusX N.To minPlusXDecreased)) -> ArraySized.ArraySized element (N.In (N.Up minX N.To minPlusX) max) -> ArraySized.ArraySized element (N.In (N.Up minXDecreased N.To minPlusXDecreased) max)"},{"name":"minSubtract","comment":" Have a specific minimum in mind? → [`minTo`](#minTo)\n\nWant to increase the upper bound by a on amount? ↓\n\n    ArraySized.l4 'a' 'b' 'c' 'd'\n        --: ArraySized Char (In (Up4 minX_) (Up4 maxX_))\n        |> ArraySized.minSubtract n2\n    --: ArraySized Char (In (Up2 minX_) (Up4 maxX_))\n\nWhen is this useful? Very rarely, to preserve type variables\n\n    emptiablePush :\n        Emptiable element possiblyOrNever_\n        ->\n            (ArraySized\n                element\n                (In\n                    (Up minX To minPlusX)\n                    (Up maxX To maxPlusX)\n                )\n             ->\n                ArraySized\n                    element\n                    (In (Up minX To minPlusX) (Up maxX To (Add1 maxPlusX)))\n            )\n    emptiablePush emptiableElementToPush =\n        case emptiableElementToPush of\n            Emptiable.Empty _ ->\n                ArraySized.maxAdd n1\n\n            Emptiable.Filled elementToPush ->\n                ArraySized.push elementToPush\n                    >> ArraySized.minSubtract n1\n\nHere, you could alternatively [`attach`](#attach) its [`fromEmptiable`](#fromEmptiable).\n\nMore in [`N.minSubtract`](https://dark.elm.dmy.fr/packages/lue-bird/elm-bounded-nat/latest/N#minSubtract)\n\n","type":"N.N (N.In maxDecreaseMin_ (N.Down minPlusX N.To minDecreasedPlusX)) -> ArraySized.ArraySized element (N.In (N.Up x N.To minPlusX) max) -> ArraySized.ArraySized element (N.In (N.Up x N.To minDecreasedPlusX) max)"},{"name":"minTo","comment":" Make an `ArraySized` with a on maximum length fit into functions with require a higher maximum length\n\n    type alias Row =\n        ArraySized Field (Exactly (On N18))\n\n`Row`'s length range can't be added to another length\n\n    attach2TemporaryFields : Row -> ...\n    attach2TemporaryFields rowFromModelOrSomeStorage =\n        ArraySized.repeat Temporary n2\n            |> ArraySized.attach Up rowFromModelOrSomeStorage\n\nOnly `Up<n> x` can do that\n\n    attach2TemporaryFields :\n        Row\n        ->\n            ArraySized\n                Field\n                (In (Up20 minX_) (Up20 maxX_))\n    attach2TemporaryFields rowFromModelOrSomeStorage =\n        ArraySized.repeat Temporary n2\n            |> ArraySized.attach Up\n                (rowFromModelOrSomeStorage\n                    |> ArraySized.minTo n18\n                    |> ArraySized.maxTo n18\n                )\n\n","type":"N.N (N.In minNew (N.Up minNewMaxToMin_ N.To min)) -> ArraySized.ArraySized element (N.In (N.On min) max) -> ArraySized.ArraySized element (N.In minNew max)"},{"name":"minTo0","comment":" Equivalent to [`minTo n0`](#minTo),\nexcept that the current length minimum isn't required to be `On`.\n\nIt can be used to make argument types to functions look nicer.\n\n","type":"ArraySized.ArraySized element (N.In min_ max) -> ArraySized.ArraySized element (N.In (N.Up0 minX_) max)"},{"name":"minToNumber","comment":" [`ArraySized`](#ArraySized) with a [`length`](#length)\nwith an [`On`](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#On) minimum\n→ equatable [`OnValue`](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#OnValue) minimum\n\nYou'll usually use this to convert to a `Min (OnValue ...)` length\n\n","type":"ArraySized.ArraySized element (N.In (N.On min) max) -> ArraySized.ArraySized element (N.In min max)"},{"name":"minToOn","comment":" [`ArraySized`](#ArraySized) with a [`length`](#length)\nwith an equatable [`OnValue`](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#OnValue) minimum\n→ [`On`](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#On) minimum,\nallowing it to be [altered](#alter), [compared](#observe-length), ...\n\nYou'll usually use this to convert to a `Min (On ...)` length\n\n","type":"ArraySized.ArraySized element (N.In min max) -> ArraySized.ArraySized element (N.In (N.On min) max)"},{"name":"n1To","comment":" Increasing natural numbers from `n1` until including a given number\n\n    import N exposing (n3, n0)\n\n    ArraySized.n1To n3\n    --: ArraySized\n    --:     (N (In (Up1 nMinX_) (Up3 maxX)))\n    --:     (In (Up3 minX_) (Up3 maxX))\n        |> ArraySized.map N.toInt\n        |> ArraySized.toList\n    --> [ 1, 2, 3 ]\n\n    ArraySized.n1To n0\n    --: ArraySized\n    --:     (N (In (Up1 nMinX_) (Up0 maxX)))\n    --:     (In (Up0 minX_) (Up0 maxX))\n        |> ArraySized.map N.toInt\n        |> ArraySized.toList\n    --> []\n    -- This does look weird at first glance...\n    -- The ArraySized says it has Ns in it that are impossible to construct!\n    -- but I promise it makes sense:\n    -- The ArraySized is empty, so we're all good after all\n\n    ArraySized.n1To between2And9\n        |> ArraySized.map (N.add n3)\n    --: ArraySized\n    --:    (N (In (Up5 nMinX_) (Up12 maxX)))\n    --:    (In (Up3 minX_) (Up10 maxX))\n\nTo add index info to your `ArraySized`, use [`andIndexes`](#andIndexes)\n\n","type":"N.N (N.In (N.Up minX N.To minPlusX) max) -> ArraySized.ArraySized (N.N (N.In (N.Up1 nMinX_) max)) (N.In (N.Up minX N.To minPlusX) max)"},{"name":"one","comment":" Create with only 1 single given element\n","type":"element -> ArraySized.ArraySized element (N.In (N.Up1 minX_) (N.Up1 maxX_))"},{"name":"push","comment":" Put a new element after all the others\n\n    between5And10Elements\n        |> ArraySized.push \"becomes the last\"\n    --: ArraySized String (In (Up6 minX_) (Up11 maxX_))\n\n[`pushMin`](#pushMin) if you don't know the length maximum\n\n","type":"element -> ArraySized.ArraySized element (N.In (N.Up minX N.To minPlusX) (N.Up maxX N.To maxPlusX)) -> ArraySized.ArraySized element (N.In (N.Up minX N.To (N.Add1 minPlusX)) (N.Up maxX N.To (N.Add1 maxPlusX)))"},{"name":"pushMin","comment":" Put a new element after all the others\n\n    atLeast5Elements\n        |> ArraySized.pushMin \"becomes the last\"\n    --: ArraySized String (Min (Up6 minX_))\n\n[`push`](#push) if you know the length maximum\n\n","type":"element -> ArraySized.ArraySized element (N.In (N.Up minX N.To minPlusX) max_) -> ArraySized.ArraySized element (N.Min (N.Up minX N.To (N.Add1 minPlusX)))"},{"name":"random","comment":" `Random.Generator` for a given amount of random elements\n\n    import N exposing (n5)\n\n    ArraySized.random (Random.float 0 1) n5\n    --: Random.Generator\n    --:     (ArraySized\n    --:         Float\n    --:         (In (Up5 minX_) (Up5 maxX_))\n    --:     )\n\nPairs well with\n\n    Random.andThen\n        (ArraySized.random <element>)\n        (N.randomIn ( <length min>, <length max> ))\n\n","type":"Random.Generator element -> N.N range -> Random.Generator (ArraySized.ArraySized element range)"},{"name":"remove","comment":" Kick out the element at a given index\nin a given [`Direction`](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\n\nRemember that indexes are 1-indexed!\n\n    import Linear exposing (Direction(..))\n    import N exposing (n1)\n\n    removeLast between1And10Elements =\n        between1And10Elements\n            |> ArraySized.remove ( Down, n1 )\n\n  - Don't know the length maximum? → [`removeMin`](#removeMin)\n  - Want to remove an element beyond the length minimum? → [`removeMin`](#removeMin)\n\n","type":"( Linear.Direction, N.N (N.In (N.On (N.Add1 indexMinFrom1_)) (N.Up indexMaxToMinFrom1_ N.To (N.Add1 minFrom1))) ) -> ArraySized.ArraySized element (N.In (N.On (N.Add1 minFrom1)) (N.Up maxX N.To (N.Add1 maxFrom1PlusX))) -> ArraySized.ArraySized element (N.In (N.On minFrom1) (N.Up maxX N.To maxFrom1PlusX))"},{"name":"removeMin","comment":" Kick out the element at an index\nin a given [`Direction`](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\n\nRemember that indexes are 1-indexed!\n\n    removeLast =\n        ArraySized.removeMin ( Down, n0 )\n\nThis only works when the [`ArraySized`](#ArraySized)\nhas at minimum 1 element.\nTo _maybe_ remove an element,\nmatch on [`ArraySized.hasAtLeast n1`](#hasAtLeast)\n\n  - Know the length maximum? → [`remove`](#remove)\n  - Want to make the length minimum a difference again (not `On`) for results, ...?\n    → [`ArraySized.minTo`](#minTo)\n\n","type":"( Linear.Direction, N.N (N.In (N.On (N.Add1 indexMinFrom1_)) indexMax_) ) -> ArraySized.ArraySized element (N.In (N.On (N.Add1 minFrom1)) max) -> ArraySized.ArraySized element (N.In (N.On minFrom1) max)"},{"name":"repeat","comment":" A given amount of same elements\n\n    import N exposing (n4)\n\n    ArraySized.repeat 'L' n4\n        --: ArraySized Char (In (Up4 minX_) (Up4 maxX_))\n        |> ArraySized.toList\n    --> [ 'L', 'L', 'L', 'L' ]\n\n    ArraySized.repeat 'L' atLeast3\n    --: Char ArraySized (Min (Up3 x_))\n\n","type":"element -> N.N range -> ArraySized.ArraySized element range"},{"name":"reverse","comment":" Flip the order of the elements\n\n    ArraySized.l4 \"l\" \"i\" \"v\" \"e\"\n        |> ArraySized.reverse\n        |> ArraySized.toList\n    --> [ \"e\", \"v\", \"i\", \"l\" ]\n\n","type":"ArraySized.ArraySized element range -> ArraySized.ArraySized element range"},{"name":"take","comment":" A given number of elements\nin a given [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\n\n    import Linear exposing (Direction(..))\n    import N exposing (n7)\n\n    -- its three last elements\n    ArraySized.n1To n3AtLeast\n        |> ArraySized.take Down { atLeast = n3 } n3\n\nIs the amount taken less than the `ArraySized`'s length minimum?\n\n    ArraySized.l8 0 1 2 3 4 5 6 7\n        |> ArraySized.take Up { atLeast = n7 } n7\n        --: ArraySized number_ (In (Up7 minX_) (Up7 maxX_))\n        |> ArraySized.toList\n    --> [ 0, 1, 2, 3, 4, 5, 6 ]\n\n    ArraySized.l8 0 1 2 3 4 5 6 7\n        |> ArraySized.take Up { atLeast = n7 } n7AtLeast\n    --: ArraySized number_ (Min (Up7 x_))\n\n    ArraySized.l8 0 1 2 3 4 5 6 7\n        |> ArraySized.minTo\n        |> ArraySized.take Up { atLeast = n2 } between2And7\n    --: ArraySized number_ (In (Up2 minX_) (Up7 maxX_))\n\nIs the amount taken greater than the `ArraySized`'s length minimum?\n\n    ArraySized.n1To between3And6\n        -- its first four elements\n        |> ArraySized.take Down { atLeast = n3 } (n4 |> N.minTo n3)\n\nIf you're having trouble understanding the `atLeast` field, think of looking\nat the implementation of `take` will help:\n\n    take direction { atLeast } toTakeAmount =\n        minTo atLeast\n            >> takeCurrentMin direction toTakeAmount\n\nOpen for alternative API suggestions! I'm actually close to removing\n`take` in favor of [`takeCurrentMin`](#takeCurrentMin)\nand renaming that to `take`. Let me know what you think!\n\n","type":"Linear.Direction -> { atLeast : N.N (N.In takenMin (N.Up takenMaxToMin_ N.To min)) } -> N.N (N.In takenMin takenMax) -> ArraySized.ArraySized element (N.In (N.On min) max_) -> ArraySized.ArraySized element (N.In takenMin takenMax)"},{"name":"takeCurrentMin","comment":" Take a given number of elements\nin a given [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\n\nAs the simpler version of [`take`](#take)\nyou can only take at least the type's minimum amount.\n\nIt's most of the time not what you want, since\nyou usually want a shorter array minimum after taking.\n\n","type":"Linear.Direction -> N.N (N.In min takenMax) -> ArraySized.ArraySized element (N.In min max_) -> ArraySized.ArraySized element (N.In min takenMax)"},{"name":"to10","comment":" Transform into a `Toop.T10` to simplify accessing elements, pattern matching\n","type":"ArraySized.ArraySized element (N.In (N.On (N.Add10 minFrom10_)) (N.Up maxTo10_ N.To N.N10)) -> Toop.T10 element element element element element element element element element element"},{"name":"to11","comment":" Transform into a `Toop.T11` to simplify accessing elements, pattern matching\n","type":"ArraySized.ArraySized element (N.In (N.On (N.Add11 minFrom11_)) (N.Up maxTo11_ N.To N.N11)) -> Toop.T11 element element element element element element element element element element element"},{"name":"to12","comment":" Transform into a `Toop.T12` to simplify accessing elements, pattern matching\n","type":"ArraySized.ArraySized element (N.In (N.On (N.Add12 minFrom2_)) (N.Up maxTo12_ N.To N.N12)) -> Toop.T12 element element element element element element element element element element element element"},{"name":"to13","comment":" Transform into a `Toop.T13` to simplify accessing elements, pattern matching\n","type":"ArraySized.ArraySized element (N.In (N.On (N.Add13 minFrom13_)) (N.Up maxTo13_ N.To N.N13)) -> Toop.T13 element element element element element element element element element element element element element"},{"name":"to14","comment":" Transform into a `Toop.T14` to simplify accessing elements, pattern matching\n","type":"ArraySized.ArraySized element (N.In (N.On (N.Add14 minFrom14_)) (N.Up maxTo14_ N.To N.N14)) -> Toop.T14 element element element element element element element element element element element element element element"},{"name":"to15","comment":" Transform into a `Toop.T15` to simplify accessing elements, pattern matching\n","type":"ArraySized.ArraySized element (N.In (N.On (N.Add15 minFrom15_)) (N.Up maxTo15_ N.To N.N15)) -> Toop.T15 element element element element element element element element element element element element element element element"},{"name":"to16","comment":" Transform into a `Toop.T16` to simplify accessing elements, pattern matching\n","type":"ArraySized.ArraySized element (N.In (N.On (N.Add16 minFrom16_)) (N.Up maxTo16_ N.To N.N16)) -> Toop.T16 element element element element element element element element element element element element element element element element"},{"name":"to2","comment":" Transform into a `Toop.T2` to simplify accessing elements, pattern matching\n","type":"ArraySized.ArraySized element (N.In (N.On (N.Add2 minFrom2_)) (N.Up maxTo2_ N.To N.N2)) -> Toop.T2 element element"},{"name":"to3","comment":" Transform into a `Toop.T3` to simplify accessing elements, pattern matching\n","type":"ArraySized.ArraySized element (N.In (N.On (N.Add3 minFrom3_)) (N.Up maxTo3_ N.To N.N3)) -> Toop.T3 element element element"},{"name":"to4","comment":" Transform into a `Toop.T4` to simplify accessing elements, pattern matching\n","type":"ArraySized.ArraySized element (N.In (N.On (N.Add4 minFrom4_)) (N.Up maxTo4_ N.To N.N4)) -> Toop.T4 element element element element"},{"name":"to5","comment":" Transform into a `Toop.T5` to simplify accessing elements, pattern matching\n","type":"ArraySized.ArraySized element (N.In (N.On (N.Add5 minFrom5_)) (N.Up maxTo5_ N.To N.N5)) -> Toop.T5 element element element element element"},{"name":"to6","comment":" Transform into a `Toop.T6` to simplify accessing elements, pattern matching\n","type":"ArraySized.ArraySized element (N.In (N.On (N.Add6 minFrom6_)) (N.Up maxTo6_ N.To N.N6)) -> Toop.T6 element element element element element element"},{"name":"to7","comment":" Transform into a `Toop.T7` to simplify accessing elements, pattern matching\n","type":"ArraySized.ArraySized element (N.In (N.On (N.Add7 minFrom7_)) (N.Up maxTo7_ N.To N.N7)) -> Toop.T7 element element element element element element element"},{"name":"to8","comment":" Transform into a `Toop.T8` to simplify accessing elements, pattern matching\n","type":"ArraySized.ArraySized element (N.In (N.On (N.Add8 minFrom8_)) (N.Up maxTo8_ N.To N.N8)) -> Toop.T8 element element element element element element element element"},{"name":"to9","comment":" Transform into a `Toop.T9` to simplify accessing elements, pattern matching\n","type":"ArraySized.ArraySized element (N.In (N.On (N.Add9 minFrom9_)) (N.Up maxTo9_ N.To N.N9)) -> Toop.T9 element element element element element element element element element"},{"name":"toArray","comment":" Convert to an `Array`.\n\nMake these kinds of conversions your final step.\nTry to keep extra information as long as you can: [\"wrap early, unwrap late\"](https://elm-radio.com/episode/wrap-early-unwrap-late)\n\n    import N exposing (n4)\n    import Array\n\n    ArraySized.n1To n4\n        |> ArraySized.map N.toInt\n        |> ArraySized.toArray\n    --> Array.fromList [ 1, 2, 3, 4 ]\n\n","type":"ArraySized.ArraySized element range_ -> Array.Array element"},{"name":"toChunksOf","comment":" Split the `ArraySized` into equal-sized (except `remainder`) slices\nin a given [`Direction`](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\n\n  - `chunks`: the ArraySized divided into equal-sized Arrs\n  - `remainder`: values to one side that don't fill a whole group\n\n↓\n\n    import Linear exposing (Direction(..))\n    import N exposing (n0, n5)\n\n    ArraySized.l7 1 2 3 4 5 6 7\n        |> ArraySized.toChunksOf Up n5\n        --: { chunks :\n        --:     ArraySized\n        --:         (ArraySized\n        --:             number_\n        --:             (In (Up5 chunkMinX_) (Up5 chunkMaxX))\n        --:         )\n        --:         (In (Up0 minX_) (Up7 maxX_))\n        --: , remainder :\n        --:     ArraySized\n        --:         number_\n        --:         (In\n        --:             (Up0 remainderMinX_)\n        --:             (Up4 chunkMaxX)\n        --:         )\n        --: }\n        |> .remainder\n        |> ArraySized.toList\n    --> [ 6, 7 ]\n\n\n    ArraySized.l7 1 2 3 4 5 6 7\n        |> ArraySized.toChunksOf Down n5\n        |> .remainder\n        |> ArraySized.toList\n    --> [ 1, 2 ]\n\n","type":"Linear.Direction -> N.N (N.In (N.On (N.Add1 chunkMinFrom1)) (N.Up chunkMaxX N.To (N.Add1 chunkMaxFrom1PlusX))) -> ArraySized.ArraySized element (N.In minLength_ max) -> { chunks : ArraySized.ArraySized (ArraySized.ArraySized element (N.In (N.On (N.Add1 chunkMinFrom1)) (N.Up chunkMaxX N.To (N.Add1 chunkMaxFrom1PlusX)))) (N.In (N.Up0 minX_) max), remainder : ArraySized.ArraySized element (N.In (N.Up remainderMinX N.To remainderMinX) (N.Up chunkMaxX N.To chunkMaxFrom1PlusX)) }"},{"name":"toEmptiable","comment":" On [`empty`](#empty) `Emptiable.empty`,\non [`one`](#one) `filled` with its only value\n\nEmptiness type information is transferred\n\n","type":"ArraySized.ArraySized element (N.In (N.On (N.N0OrAdd1 possiblyOrNever minFrom1_)) (N.Up maxTo1_ N.To N.N1)) -> Emptiable.Emptiable element possiblyOrNever"},{"name":"toList","comment":" Convert to a `List`.\n\nMake these kinds of conversions your final step.\nTry to keep extra information as long as you can: [\"wrap early, unwrap late\"](https://elm-radio.com/episode/wrap-early-unwrap-late)\n\n    import N exposing (n4)\n\n    ArraySized.n1To n4\n        |> ArraySized.map N.toInt\n        |> ArraySized.toList\n    --> [ 1, 2, 3, 4 ]\n\n","type":"ArraySized.ArraySized element range_ -> List.List element"},{"name":"toOne","comment":" Its one and only, first and last element\n\n    ArraySized.one \"hi\" |> ArraySized.toOne\n    --> \"hi\"\n\n","type":"ArraySized.ArraySized element (N.In (N.On (N.Add1 minFrom1_)) (N.Up maxTo1_ N.To N.N1)) -> element"},{"name":"toSize","comment":" Reach a given length:\n\n  - If the current length is greater than a given length, [`take`](#take) the new length in a given direction\n\n  - If the current length is less than a given length, pad further in a given [`Direction`](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\n    based on the index in the final [`ArraySized`](#ArraySized)\n\n.\n\n    import N exposing (n8)\n    import Linear exposing (Direction(..))\n\n    type Bit\n        = I\n        | O\n\n    ArraySized.l3 I O I\n        |> ArraySized.toSize Down n8 (\\_ -> O)\n        --: ArraySized Bit (In (On N8) (Up8 x_))\n        |> ArraySized.toList\n    --> [ O, O, O, O, O, I, O, I ]\n\n    ArraySized.l4\n        (ArraySized.l3 I I I |> ArraySized.maxTo n8)\n        (ArraySized.l8 O I I I O I O O)\n        (ArraySized.l8 O I I I O I O O)\n        (ArraySized.l8 O I I I O I O O)\n        |> ArraySized.map\n            (ArraySized.toSize Down n8 (\\_ -> O))\n        |> ArraySized.map ArraySized.toList\n        |> ArraySized.toList\n    --> [ [ O, O, O, O, O, I, I, I ]\n    --> , [ O, I, I, I, O, I, O, O ]\n    --> , [ O, I, I, I, O, I, O, O ]\n    --> , [ O, I, I, I, O, I, O, O ]\n    --> ]\n\n","type":"Linear.Direction -> N.N (N.In (N.Up newMinX N.To newMinPlusX) newMax) -> (N.N (N.In (N.Up1 indexMin_) newMax) -> element) -> ArraySized.ArraySized element range_ -> ArraySized.ArraySized element (N.In (N.Up newMinX N.To newMinPlusX) newMax)"},{"name":"toStack","comment":" Convert to an `Emptiable (Stacked ...) never_`.\n\nMake these kinds of conversions your final step.\nTry to keep extra information as long as you can: [\"wrap early, unwrap late\"](https://elm-radio.com/episode/wrap-early-unwrap-late)\n\n    import N exposing (n4)\n    import Emptiable\n    import Stack\n\n    ArraySized.n1To n4\n        |> ArraySized.map N.toInt\n        |> ArraySized.toStack\n    --> Stack.topBelow 1 [ 2, 3, 4 ]\n    --: Emptiable (Stacked Int) Never\n\n    ArraySized.l4 (0 |> Emptiable.filled) Emptiable.empty Emptiable.empty (3 |> Emptiable.filled)\n        |> ArraySized.fills\n        |> ArraySized.toStack\n    --> Stack.topBelow 0 [ 3 ]\n    --: Emptiable (Stacked Int) Possibly\n\n","type":"ArraySized.ArraySized element (N.In (N.On (N.N0OrAdd1 possiblyOrNever minFrom1_)) max_) -> Emptiable.Emptiable (Stack.Stacked element) possiblyOrNever"},{"name":"toString","comment":" Convert to a `String`.\n\nMake these kinds of conversions your final step.\nTry to keep extra information as long as you can: [\"wrap early, unwrap late\"](https://elm-radio.com/episode/wrap-early-unwrap-late)\n\n    import N exposing (n4)\n\n    ArraySized.n1To n4\n        |> ArraySized.map\n            (\\n ->\n                ('a' |> Char.toCode)\n                    + (n |> N.toInt) - 1\n                    |> Char.fromCode\n            )\n        |> ArraySized.toString\n    --> \"abcd\"\n\n","type":"ArraySized.ArraySized Char.Char range_ -> String.String"}],"binops":[]}]