[{"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 (In (Add1 minMinus1_) max_) comparable\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, random, upTo\n@docs fromArray, fromList, fromEmptiable, fromStackFilled, fromStackEmptiable, fromString\n\n\n## specific length\n\n@docs empty, l1\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# scan\n\n@docs length\n@docs element, elementTry, to1\n@docs all, any\n\n\n# alter\n\n@docs elementReplace, elementAlter, reverse\n@docs push, pushMin, insert, insertMin\n@docs elementRemove, elementRemoveMin\n\n\n## filter\n\n@docs fills, allFill\n\n\n## part\n\n@docs take, drop, dropMin, dropOverMin\n@docs toChunksOf\n\n\n## combine\n\n@docs and\n@docs glue, glueMin\n@docs padToLength\n@docs interweave, interweaveMin\n\n\n# length compare\n\n@docs hasIn, has, hasAtLeast, hasAtMost\n\n\n# transform\n\n@docs map\n@docs foldFrom, fold\n@docs toArray, toList, toEmptiable, toStackEmptiable, toStackFilled, 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 toValue, fromValue\n@docs minToValue, minFromValue\n@docs maxToValue, maxFromValue\n\n\n## type-level\n\n@docs minTo, minDown\n@docs maxTo, maxToInfinity, maxUp\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    -- amount >= 5\n    : ArraySized (Min (Up5 x_)) ...\n\n    -- 2 <= amount <= 12\n    : ArraySized\n    :     (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[glueing](#combine), [taking, dropping, chunking](#part), [comparing](#length-compare), ...\n\n\n### argument type\n\n    -- = 15\n    : ArraySized (Exactly N15) ...\n\n    -- amount >= 4\n    : ArraySized (In (Fixed (Add4 minMinus4_)) max_) ...\n\n    -- 4 <= amount <= 15\n    : ArraySized\n    :     (In (Fixed (Add4 minMinus4_)) (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 `Fixed N<n>`,\navoiding type variables\n\n    -- amount >= 4\n    : ArraySized (Min (Fixed N4)) ...\n\n    -- 4 <= amount <= 15\n    : ArraySized (InFixed N4 N15) ...\n\n    -- = 15\n    : ArraySized (Exactly N15) ...\n\n`InFixed min max` being a shorthand for\n\n    In (Fixed min) (Fixed max)\n\n`Exactly n` being a shorthand for\n\n    InFixed n n\n\n---\n\n`==` on ranges crashes elm.\nUse [safe comparison methods](#length-compare)\nor convert [`toValue`](#toValue)\n\n","args":["lengthRange","element"],"type":"ArraySized.Internal.ArraySized lengthRange element"}],"values":[{"name":"all","comment":" Whether all elements satisfy a given test\n\n    ArraySized.l2 2 3 |> ArraySized.all (\\n -> n <= 4)\n    --> True\n\n    ArraySized.l2 2 7 |> ArraySized.all (\\n -> n <= 4)\n    --> False\n\n    ArraySized.empty |> ArraySized.all (\\n -> n <= 4)\n    --> True\n\n","type":"(element -> Basics.Bool) -> ArraySized.ArraySized lengthRange_ element -> Basics.Bool"},{"name":"allFill","comment":" If every `Emptiable` is `filled`, all of the values.\nIf any element is `empty`, `empty`\n\n    import Emptiable exposing (filled, fillMap)\n\n    ArraySized.empty\n        |> ArraySized.allFill\n        |> fillMap ArraySized.toList\n    --> filled []\n\n    ArraySized.l3 (filled 1) (filled 2) (filled 3)\n        |> ArraySized.allFill\n        |> fillMap ArraySized.toList\n    --> filled [ 1, 2, 3 ]\n\n    ArraySized.l3 (filled 1) Emptiable.empty (filled 3)\n        |> ArraySized.allFill\n    --> Emptiable.empty\n\nFunnily, this 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 range (Emptiable.Emptiable value possiblyOrNever) -> Emptiable.Emptiable (ArraySized.ArraySized range value) possiblyOrNever"},{"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 length nextElement -> ArraySized.ArraySized length element -> ArraySized.ArraySized length ( element, nextElement )"},{"name":"any","comment":" Whether at least one element satisfies a given test\n\n    ArraySized.l2 300 -5 |> ArraySized.any (\\n -> n <= 4)\n    --> True\n\n    ArraySized.l2 5 5 |> ArraySized.any (\\n -> n <= 4)\n    --> False\n\n    ArraySized.empty |> ArraySized.any (\\n -> n <= 4)\n    --> False\n\n","type":"(element -> Basics.Bool) -> ArraySized.ArraySized lengthRange_ element -> Basics.Bool"},{"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\n        --:     (In (Up2 minX_) (Up2 maxX_))\n        --:     number_\n        |> ArraySized.toList\n    --> [ 0, 1 ]\n\n    between6And10Elements\n        |> ArraySized.drop ( Up, between2And3 )\n        --: ArraySized\n        --:     (In (Up3 minX_) (Up8 maxX_))\n        --:     number_\n\n  - Don't know its length maximum? → [`dropMin`](#dropMin)\n  - Can the dropped length's maximum be greater than its length's minimum? → [`dropOverMin`](#dropOverMin)\n\n","type":"( Linear.Direction, N.N (N.In (N.Down maxPlusX N.To takenMaxPlusX) (N.Down min N.To takenMin)) ) -> ArraySized.ArraySized (N.In (N.Fixed min) (N.Up maxX N.To maxPlusX)) element -> ArraySized.ArraySized (N.In (N.Fixed takenMin) (N.Up maxX N.To takenMaxPlusX)) element"},{"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 (Fixed N4)) ...\n\nKnow its length maximum? → [`drop`](#drop)\n\n","type":"( Linear.Direction, N.N (N.In dropped_ (N.Down min N.To takenMin)) ) -> ArraySized.ArraySized (N.In (N.Fixed min) max) element -> ArraySized.ArraySized (N.In (N.Fixed takenMin) max) element"},{"name":"dropOverMin","comment":" [`drop`](#drop) a given length that can be greater than the [`ArraySized`](#ArraySized)'s length maximum\n\n    import Linear exposing (Direction(..))\n    import N exposing (n2)\n\n    between3And6Elements\n        |> ArraySized.dropOverMin ( Down, n5 )\n    --: ArraySized (In (Up0 minX_) (Fixed N1)) ...\n\n","type":"( Linear.Direction, N.N (N.In (N.Down max N.To takenMax) takenMax_) ) -> ArraySized.ArraySized (N.In min_ (N.Fixed max)) element -> ArraySized.ArraySized (N.In (N.Up0 resultMinX_) (N.Fixed takenMax)) element"},{"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\n    import Linear exposing (Direction(..))\n    import N exposing (n1)\n\n    ArraySized.l4 0 1 2 3\n        |> ArraySized.element ( Up, n1 )\n    --> 1\n\n    ArraySized.l4 0 1 2 3\n        |> ArraySized.element ( Down, n1 )\n    --> 2\n\n","type":"( Linear.Direction, N.N (N.In indexMin_ (N.Up indexMaxToMinMinus1_ N.To minMinus1)) ) -> ArraySized.ArraySized (N.In (N.Fixed (N.Add1 minMinus1)) max_) element -> 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 range element -> ArraySized.ArraySized range element"},{"name":"elementRemove","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\n    import Linear exposing (Direction(..))\n    import N exposing (n0)\n\n    removeLast between1And10Elements =\n        between1And10Elements\n            |> ArraySized.elementRemove ( Down, n0 )\n\n  - Don't know the length maximum? → [`elementRemoveMin`](#elementRemoveMin)\n  - Want to remove an element beyond the length minimum? → [`elementRemoveMin`](#elementRemoveMin)\n\n","type":"( Linear.Direction, N.N (N.In indexMin_ (N.Up indexMaxToMinMinus1_ N.To minMinus1)) ) -> ArraySized.ArraySized (N.In (N.Fixed (N.Add1 minMinus1)) (N.Up maxX N.To (N.Add1 maxMinus1PlusX))) element -> ArraySized.ArraySized (N.In (N.Fixed minMinus1) (N.Up maxX N.To maxMinus1PlusX)) element"},{"name":"elementRemoveMin","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\n    removeLast =\n        ArraySized.elementRemoveMin ( 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? → [`elementRemove`](#elementRemove)\n  - Want to make the length minimum a difference again (not `Fixed`) for results, ...?\n    → [`ArraySized.minTo`](#minTo)\n\n","type":"( Linear.Direction, N.N indexRange_ ) -> ArraySized.ArraySized (N.In (N.Fixed (N.Add1 minMinus1)) max) element -> ArraySized.ArraySized (N.In (N.Fixed minMinus1) max) element"},{"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 range element -> ArraySized.ArraySized range element"},{"name":"elementTry","comment":" Its possible element at a 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 a `Result`\n\n    import Linear exposing (Direction(..))\n    import N exposing (n1, n5)\n\n    ArraySized.l4 0 1 2 3\n        |> ArraySized.elementTry ( Up, n5 )\n    --> Err { indexBeyondElements = () }\n\n    ArraySized.l4 0 1 2 3\n        |> ArraySized.elementTry ( Down, n1 )\n    --> Ok 2\n\n","type":"( Linear.Direction, N.N range_ ) -> ArraySized.ArraySized lengthRange_ element -> Result.Result { indexBeyondElements : () } element"},{"name":"empty","comment":" No elements\n\n    ArraySized.empty\n    --: ArraySized (In (Up0 minX_) (Up0 maxX_)) element_\n        |> ArraySized.push \":)\"\n        --: ArraySized\n        --:     (In (Up1 minX_) (Up1 maxX_))\n        --:     String\n\n","type":"ArraySized.ArraySized (N.In (N.Up0 minX_) (N.Up0 maxX_)) element_"},{"name":"fills","comment":" Take every `filled value`, drop every `empty`\n\n    import Emptiable exposing (filled)\n\n    ArraySized.l3 (filled \"This\") Emptiable.empty (filled \"fine\")\n        |> ArraySized.fills\n        --: ArraySized\n        --:     (In (Up0 minX_) (Up3 maxX_))\n        --:     String\n        |> ArraySized.toList\n    --> [ \"This\", \"fine\" ]\n\n[`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 (N.In (N.Fixed min_) max) (Emptiable.Emptiable value possiblyOrNever_) -> ArraySized.ArraySized (N.In (N.Up0 minX_) max) value"},{"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 (N.In (N.Fixed (N.Add1 minMinus1_)) max_) element -> 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 lengthRange_ element -> result"},{"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.upTo 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 (N.Min (N.Up0 x_)) element"},{"name":"fromEmptiable","comment":" On `Just` [`ArraySized.l1`](#l1), on `Nothing` [`empty`](#empty)\n\n    import N exposing (n0)\n    import Emptiable exposing (filled)\n\n    filled \"hi\"\n        |> ArraySized.fromEmptiable\n        --: ArraySized\n        --:     (In (Up0 minX_) (Up1 maxX_))\n        |> ArraySized.toList\n    --> [ \"hi\" ]\n\n    Emptiable.empty\n        |> ArraySized.fromEmptiable\n        --: ArraySized\n        --:     (In (Up0 minX_) (Up1 maxX_))\n        |> ArraySized.toList\n    --> []\n\nSadly, they way natural number constraints are defined,\n`possiblyOrNever` can't be transferred\n\n","type":"Emptiable.Emptiable element possiblyOrNever_ -> ArraySized.ArraySized (N.In (N.Up0 minX_) (N.Up1 maxX_)) element"},{"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.upTo 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 (N.Min (N.Up0 x_)) element"},{"name":"fromStackEmptiable","comment":" Create from a `Stack`.\nAs every `Stack` has `>= 0` elements:\n\n    listFromSomeOtherLibrary |> ArraySized.fromStackEmptiable\n    --: ArraySized (Min (Up0 x_))\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.upTo n6 -- big yes\n\n[\"wrap early, unwrap late\"](https://elm-radio.com/episode/wrap-early-unwrap-late)\n\nHave an `Emptiable (Stacked ...) Never`? → [`fromStackFilled`](#fromStackFilled)\n\n","type":"Emptiable.Emptiable (Stack.Stacked element) possiblyOrNever_ -> ArraySized.ArraySized (N.Min (N.Up0 x_)) element"},{"name":"fromStackFilled","comment":" Create from a `Stack`.\nAs every `Stack` has `>= 0` elements:\n\n    listFromSomeOtherLibrary |> ArraySized.fromStackFilled\n    --: ArraySized (Min (Up1 x_))\n\nDon't use for construction:\n\n    ArraySized.fromStackFilled\n        (Stack.topDown 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.upTo n6 -- big yes\n\n[\"wrap early, unwrap late\"](https://elm-radio.com/episode/wrap-early-unwrap-late)\n\nOnly have an `Emptiable (Stacked ...) Possibly`? → [`fromStackEmptiable`](#fromStackEmptiable)\n\n","type":"Emptiable.Emptiable (Stack.Stacked element) Basics.Never -> ArraySized.ArraySized (N.Min (N.Up1 x_)) element"},{"name":"fromString","comment":" Create from a `String`.\nAs every `String` has `>= 0` elements:\n\n    stringFromSomeOtherLibrary |> ArraySized.fromString\n    --: ArraySized (Min (Up0 x_)) Char\n\nTry not to use this for construction\nand instead use the safe versions like `l<n>`\n\n","type":"String.String -> ArraySized.ArraySized (N.Min (N.Up0 minX_)) Char.Char"},{"name":"fromValue","comment":" [`ArraySized`](#ArraySized) with a [`length`](#length)\nof equatable [`Value` range](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#InValue)\n→ [Fixed range](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#InFixed),\nallowing it to be [altered](#alter), [compared](#length-compare), ...\n","type":"ArraySized.ArraySized (N.InValue min max) element -> ArraySized.ArraySized (N.InFixed min max) element"},{"name":"glue","comment":" Attach elements of an `ArraySized` with an exact amount of elements to 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.glue Up (ArraySized.l3 4 5 6)\n        --: ArraySized\n        --:     (In (Up6 minX_) (Up6 maxX_))\n        --:     number_\n        |> ArraySized.toList\n    --> [ 1, 2, 3, 4, 5, 6 ]\n\n    ArraySized.l3 1 2 3\n        |> ArraySized.glue Down (ArraySized.l3 4 5 6)\n        |> ArraySized.toList\n    --> [ 4, 5, 6, 1, 2, 3 ]\n\nDon't know both length maxima? → [`glueMin`](#glueMin)\n\n","type":"Linear.Direction -> ArraySized.ArraySized (N.In (N.Up minPlusX N.To minSumPlusX) (N.Up maxPlusX N.To maxSumPlusX)) element -> ArraySized.ArraySized (N.In (N.Up minX N.To minPlusX) (N.Up maxX N.To maxPlusX)) element -> ArraySized.ArraySized (N.In (N.Up minX N.To minSumPlusX) (N.Up maxX N.To maxSumPlusX)) element"},{"name":"glueMin","comment":" Attach elements of an `ArraySized`\nto the end in a given [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\n\n    ArraySized.l3 1 2 3\n        |> ArraySized.glueMin Up atLeast3Elements\n    --: ArraySized (Min (Up6 x_)) ...\n\n    ArraySized.l3 1 2 3\n        |> ArraySized.glueMin Down atLeast3Elements\n    --: ArraySized (Min (Up6 x_)) ...\n\nKnow both length maxima? → [`glue`](#glue)\n\n","type":"Linear.Direction -> ArraySized.ArraySized (N.In (N.Up minPlusX N.To minSumPlusX) extensionMax_) element -> ArraySized.ArraySized (N.In (N.Up x N.To minPlusX) max_) element -> ArraySized.ArraySized (N.Min (N.Up x N.To minSumPlusX)) element"},{"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 (In min N50) Character\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 comparedAgainstMinPlusXMinus1)) (N.Up maxX N.To (N.Add1 comparedAgainstMaxPlusXMinus1))) -> ArraySized.ArraySized (N.In min max) element -> Result.Result (N.BelowOrAbove (ArraySized.ArraySized (N.In min (N.Up maxX N.To comparedAgainstMaxPlusXMinus1)) element) (ArraySized.ArraySized (N.In (N.Up minX N.To (N.Add2 comparedAgainstMinPlusXMinus1)) max) element)) (ArraySized.ArraySized (N.In (N.Up minX N.To (N.Add1 comparedAgainstMinPlusXMinus1)) (N.Up maxX N.To (N.Add1 comparedAgainstMaxPlusXMinus1))) element)"},{"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 (In minLength_ max) element\n        -> Maybe (ArraySized (In (Up5 minX_) max) element)\n    atLeast5 =\n        ArraySized.hasAtLeast n5\n            >> Result.toMaybe\n\n","type":"N.N (N.In lowerLimitMin (N.Up lowerLimitMaxX N.To (N.Add1 lowerLimitMaxMinus1PlusX))) -> ArraySized.ArraySized (N.In min max) element -> Result.Result (ArraySized.ArraySized (N.In min (N.Up lowerLimitMaxX N.To lowerLimitMaxMinus1PlusX)) element) (ArraySized.ArraySized (N.In lowerLimitMin max) element)"},{"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 (In (Add3 minMinus3_) (Up maxTo50_ To N50)) String\n        -> (Metadata -> MetadataTagged)\n\n    tagIfValidTags :\n        ArraySized (In (Add3 minMinus3_) max_)\n        -> Metadata\n        -> 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 (N.In min max) element -> Result.Result (ArraySized.ArraySized (N.In (N.Up upperLimitMinX N.To (N.Add1 upperLimitMinPlusX)) max) element) (ArraySized.ArraySized (N.In min upperLimitMax) element)"},{"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 (In minLength_ N50) Character\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 lowerLimitMaxPlusXMinus1))), N.N (N.In (N.Up upperLimitMinX N.To upperLimitMinPlusX) upperLimitMax) ) -> ArraySized.ArraySized (N.In min max) element -> Result.Result (N.BelowOrAbove (ArraySized.ArraySized (N.In min (N.Up lowerLimitMaxX N.To lowerLimitMaxPlusXMinus1)) element) (ArraySized.ArraySized (N.In (N.Up upperLimitMinX N.To (N.Add1 upperLimitMinPlusX)) max) element)) (ArraySized.ArraySized (N.In lowerLimitMin upperLimitMax) element)"},{"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\n    import Linear exposing (Direction(..))\n    import N exposing (n1, n2)\n\n    ArraySized.l3 'a' 'c' 'd'\n        |> ArraySized.insert ( Up, n1 ) 'b'\n        --: ArraySized\n        --:     (In (Fixed N4) (Up4 maxX_))\n        --:     Char\n        |> ArraySized.toList\n    --> [ 'a', 'b', 'c', 'd' ]\n\n    ArraySized.l3 'a' 'c' 'd'\n        |> ArraySized.insert ( Down, n2 ) '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 `Fixed`\n(for results etc.) → [`|> minTo`](#minTo)\n\n","type":"( Linear.Direction, N.N (N.In indexMin_ (N.Up indexMaxToMin_ N.To min)) ) -> element -> ArraySized.ArraySized (N.In (N.Fixed min) (N.Up maxX N.To maxPlusX)) element -> ArraySized.ArraySized (N.In (N.Fixed (N.Add1 min)) (N.Up maxX N.To (N.Add1 maxPlusX))) element"},{"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 (Min (Fixed N6)) String\n\n    minCons :\n        element\n        -> ArraySized (In (Fixed min) max_) element\n        -> ArraySized (Min (Fixed (Add1 min))) element\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 `Fixed`\n(for results etc.) → [`|> minTo`](#minTo)\n\n","type":"( Linear.Direction, N.N (N.In indexMin_ (N.Up indexMaxToMin_ N.To min)) ) -> element -> ArraySized.ArraySized (N.In (N.Fixed min) (N.Up x_ N.To maxPlusX_)) element -> ArraySized.ArraySized (N.Min (N.Fixed (N.Add1 min))) element"},{"name":"interweave","comment":" Place all elements of an [`ArraySized`](#ArraySized)\nbetween all current members.\nExtra elements of either [`ArraySized`](#ArraySized) are glued 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\n        --:     (In (Up5 minX_) (Up5 maxX_))\n        --:     String\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\n    --:     (In (Up5 minX_) (Up13 maxX_))\n    --:     String\n\nDon't know both maxima → [`interweaveMin`](#interweaveMin)\n\n","type":"ArraySized.ArraySized (N.In (N.Up minPlusX N.To minSumPlusX) (N.Up maxPlusX N.To maxSumPlusX)) element -> ArraySized.ArraySized (N.In (N.Up x N.To minPlusX) (N.Up x N.To maxPlusX)) element -> ArraySized.ArraySized (N.In (N.Up x N.To minSumPlusX) (N.Up x N.To maxSumPlusX)) element"},{"name":"interweaveMin","comment":" Place all elements of an [`ArraySized`](#ArraySized)\nbetween all current members.\nExtra elements of either [`ArraySized`](#ArraySized) are glued 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 (ArraySized.repeat \"on\" atLeast2)\n        --: ArraySized (Min (Up5 minX_)) String\n\nKnow both maxima → [`interweave`](#interweave)\n\n","type":"ArraySized.ArraySized (N.In (N.Up minPlusX N.To minSumPlusX) interweaveMax_) element -> ArraySized.ArraySized (N.In (N.Up x N.To minPlusX) max_) element -> ArraySized.ArraySized (N.Min (N.Up x N.To minSumPlusX)) element"},{"name":"l1","comment":" Create with only 1 single given element\n","type":"element -> ArraySized.ArraySized (N.In (N.Up1 minX_) (N.Up1 maxX_)) element"},{"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 (N.In (N.Up10 minX_) (N.Up10 maxX_)) element"},{"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 (N.In (N.Up11 minX_) (N.Up11 maxX_)) element"},{"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 (N.In (N.Up12 minX_) (N.Up12 maxX_)) element"},{"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 (N.In (N.Up13 minX_) (N.Up13 maxX_)) element"},{"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 (N.In (N.Up14 minX_) (N.Up14 maxX_)) element"},{"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 (N.In (N.Up15 minX_) (N.Up15 maxX_)) element"},{"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 (N.In (N.Up16 minX_) (N.Up16 maxX_)) element"},{"name":"l2","comment":" Create with 2 given elements in the order they are supplied\n","type":"element -> element -> ArraySized.ArraySized (N.In (N.Up2 minX_) (N.Up2 maxX_)) element"},{"name":"l3","comment":" Create with 3 given elements in the order they are supplied\n","type":"element -> element -> element -> ArraySized.ArraySized (N.In (N.Up3 minX_) (N.Up3 maxX_)) element"},{"name":"l4","comment":" Create with 4 given elements in the order they are supplied\n","type":"element -> element -> element -> element -> ArraySized.ArraySized (N.In (N.Up4 minX_) (N.Up4 maxX_)) element"},{"name":"l5","comment":" Create with 5 given elements in the order they are supplied\n","type":"element -> element -> element -> element -> element -> ArraySized.ArraySized (N.In (N.Up5 minX_) (N.Up5 maxX_)) element"},{"name":"l6","comment":" Create with 6 given elements in the order they are supplied\n","type":"element -> element -> element -> element -> element -> element -> ArraySized.ArraySized (N.In (N.Up6 minX_) (N.Up6 maxX_)) element"},{"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 (N.In (N.Up7 minX_) (N.Up7 maxX_)) element"},{"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 (N.In (N.Up8 minX_) (N.Up8 maxX_)) element"},{"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 (N.In (N.Up9 minX_) (N.Up9 maxX_)) element"},{"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 range element_ -> N.N range"},{"name":"map","comment":" Change all elements based on their current values\n\n    import N exposing (n25)\n\n    aToZ : ArraySized (In N26 (N26Plus a_)) Char\n    aToZ =\n        ArraySized.upTo 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 range element -> ArraySized.ArraySized range mappedElement"},{"name":"maxFromValue","comment":" [`ArraySized`](#ArraySized) with a [`length`](#length)\nwith an equatable [`Value`](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#Value) maximum\n→ [`Fixed`](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#Fixed) maximum,\nallowing it to be [altered](#alter), [compared](#length-compare), ...\n","type":"ArraySized.ArraySized (N.In min (N.Value max)) element -> ArraySized.ArraySized (N.In min (N.Fixed max)) element"},{"name":"maxTo","comment":" Make an `ArraySized` with a fixed maximum length fit into functions with require a higher maximum length\n\n    type alias Row =\n        ArraySized (Exactly N18) Field\n\n`Row`'s length range can't be added to another length\n\n    glue2TemporaryFields : Row -> ...\n    glue2TemporaryFields rowFromModelOrSomeStorage =\n        ArraySized.repeat Temporary n2\n            |> ArraySized.glue Up rowFromModelOrSomeStorage\n\nOnly `Up<n> x` can do that:\n\n    glue2TemporaryFields :\n        Row\n        ->\n            ArraySized\n                (In (Up20 minX_) (Up20 maxX_))\n                Field\n    glue2TemporaryFields rowFromModelOrSomeStorage =\n        ArraySized.repeat Temporary n2\n            |> ArraySized.glue 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[`maxUp n1`](#maxUp) 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.Fixed maxNewMin) maxNew) -> ArraySized.ArraySized (N.In min (N.Up maxToMaxNewMin_ N.To maxNewMin)) element -> ArraySized.ArraySized (N.In min maxNew) element"},{"name":"maxToInfinity","comment":" Convert the `ArraySized (In min ...)` to a `ArraySized (Min min)`\n\n    between4And10Elements |> ArraySized.maxToInfinity\n    --: ArraySized (Min N4) ...\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> But 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 (N.In min max_) element -> ArraySized.ArraySized (N.Min min) element"},{"name":"maxToValue","comment":" [`ArraySized`](#ArraySized) with a [`length`](#length)\nwith a [`Fixed`](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#InValue) maximum\n→ equatable [`Value`](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#Value) maximum\n","type":"ArraySized.ArraySized (N.In min (N.Fixed max)) element -> ArraySized.ArraySized (N.In min (N.Value max)) element"},{"name":"maxUp","comment":" Have a specific maximum in mind? → [`maxTo`](#maxTo)\n\nWant to increase the upper bound by a fixed amount? ↓\n\n    ArraySized.l4 'a' 'b' 'c' 'd'\n        --: ArraySIzed (In (Up4 minX_) (Up4 maxX_))\n        |> ArraySized.maxUp n2\n    --: ArraySIzed (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                (In\n                    (Up minX To minPlusX)\n                    (Up maxX To maxPlusX)\n                )\n                element\n             ->\n                ArraySized\n                    (In (Up minX To minPlusX) (Up maxX To (Add1 maxPlusX)))\n                    element\n            )\n    emptiablePush emptiableElementToPush =\n        case emptiableElementToPush of\n            Emptiable.Empty _ ->\n                ArraySized.maxUp n1\n\n            Emptiable.Filled elementToPush ->\n                ArraySized.push elementToPush\n                    >> ArraySized.minDown n1\n\nMore in [`N.maxUp`](https://dark.elm.dmy.fr/packages/lue-bird/elm-bounded-nat/latest/N#maxUp)\n\n","type":"N.N (N.In maxIncreaseMin_ (N.Up maxPlusX N.To maxIncreasedPlusX)) -> ArraySized.ArraySized (N.In min (N.Up x N.To maxPlusX)) element -> ArraySized.ArraySized (N.In min (N.Up x N.To maxIncreasedPlusX)) element"},{"name":"minDown","comment":" Have a specific minimum in mind? → [`minTo`](#minTo)\n\nWant to increase the upper bound by a fixed amount? ↓\n\n    ArraySized.l4 'a' 'b' 'c' 'd'\n        --: ArraySIzed (In (Up4 minX_) (Up4 maxX_))\n        |> ArraySized.minDown n2\n    --: ArraySIzed (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                (In\n                    (Up minX To minPlusX)\n                    (Up maxX To maxPlusX)\n                )\n                element\n             ->\n                ArraySized\n                    (In (Up minX To minPlusX) (Up maxX To (Add1 maxPlusX)))\n                    element\n            )\n    emptiablePush emptiableElementToPush =\n        case emptiableElementToPush of\n            Emptiable.Empty _ ->\n                ArraySized.maxUp n1\n\n            Emptiable.Filled elementToPush ->\n                ArraySized.push elementToPush\n                    >> ArraySized.minDown n1\n\nMore in [`N.minDown`](https://dark.elm.dmy.fr/packages/lue-bird/elm-bounded-nat/latest/N#minDown)\n\n","type":"N.N (N.In maxDecreaseMin_ (N.Down minPlusX N.To minDecreasedPlusX)) -> ArraySized.ArraySized (N.In (N.Up x N.To minPlusX) max) element -> ArraySized.ArraySized (N.In (N.Up x N.To minDecreasedPlusX) max) element"},{"name":"minFromValue","comment":" [`ArraySized`](#ArraySized) with a [`length`](#length)\nwith an equatable [`Value`](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#Value) minimum\n→ [`Fixed`](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#Fixed) minimum,\nallowing it to be [altered](#alter), [compared](#length-compare), ...\n","type":"ArraySized.ArraySized (N.In (N.Value min) max) element -> ArraySized.ArraySized (N.In (N.Fixed min) max) element"},{"name":"minTo","comment":" Make an `ArraySized` with a fixed maximum length fit into functions with require a higher maximum length\n\n    type alias Row =\n        ArraySized (Exactly N18) Field\n\n`Row`'s length range can't be added to another length\n\n    glue2TemporaryFields : Row -> ...\n    glue2TemporaryFields rowFromModelOrSomeStorage =\n        ArraySized.repeat Temporary n2\n            |> ArraySized.glue Up rowFromModelOrSomeStorage\n\nOnly `Up<n> x` can do that:\n\n    glue2TemporaryFields :\n        Row\n        ->\n            ArraySized\n                (In (Up20 minX_) (Up20 maxX_))\n                Field\n    glue2TemporaryFields rowFromModelOrSomeStorage =\n        ArraySized.repeat Temporary n2\n            |> ArraySized.glue 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 (N.In (N.Fixed min) max) element -> ArraySized.ArraySized (N.In minNew max) element"},{"name":"minToValue","comment":" [`ArraySized`](#ArraySized) with a [`length`](#length)\nwith a [`Fixed`](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#Fixed) minimum\n→ equatable [`Value`](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#Value) minimum\n","type":"ArraySized.ArraySized (N.In (N.Fixed min) max) element -> ArraySized.ArraySized (N.In (N.Value min) max) element"},{"name":"padToLength","comment":" Pad in a given [`Direction`](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\nwith a given [`ArraySized`](#ArraySized)\nto reach a given length\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.padToLength Down (ArraySized.repeat O) n8\n        --: ArraySized (In (Fixed 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.padToLength Down (ArraySized.repeat O) n8)\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.Fixed paddingMin) (N.Up maxX N.To paddingMaxPlusX)) -> ArraySized.ArraySized (N.In (N.Fixed paddingMin) (N.Up maxX N.To paddingMaxPlusX)) element) -> N.N (N.In (N.Fixed paddedMin) (N.Up maxX N.To paddedMaxPlusX)) -> ArraySized.ArraySized (N.In (N.Up paddingMaxPlusX N.To paddedMaxPlusX) (N.Up paddingMin N.To paddedMin)) element -> ArraySized.ArraySized (N.In (N.Fixed paddedMin) (N.Up maxX N.To paddedMaxPlusX)) element"},{"name":"push","comment":" Put a new element after all the others\n\n    between5And10Elements\n        |> ArraySized.push \"becomes the last\"\n    --: ArraySized\n    --:     (In (Up6 minX_) (Up11 maxX_))\n    --:     String\n\n[`pushMin`](#pushMin) if you don't know the length maximum\n\n","type":"element -> ArraySized.ArraySized (N.In (N.Up minX N.To minPlusX) (N.Up maxX N.To maxPlusX)) element -> ArraySized.ArraySized (N.In (N.Up minX N.To (N.Add1 minPlusX)) (N.Up maxX N.To (N.Add1 maxPlusX))) element"},{"name":"pushMin","comment":" Put a new element after all the others\n\n    atLeast5Elements\n        |> ArraySized.pushMin \"becomes the last\"\n    --: ArraySized (Min (Up6 minX_)) String\n\n[`push`](#push) if you know the length maximum\n\n","type":"element -> ArraySized.ArraySized (N.In (N.Up minX N.To minPlusX) (N.Up maxX_ N.To maxPlusX_)) element -> ArraySized.ArraySized (N.Min (N.Up minX N.To (N.Add1 minPlusX))) element"},{"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    --:         (In (Up5 minX_) (Up5 maxX_))\n    --:         Float\n    --:     )\n\nPairs really well with\n\n    N.randomIn ( <length min>, <length max> )\n        |> Random.andThen\n            (ArraySized.random <element>)\n\n","type":"Random.Generator element -> N.N range -> Random.Generator (ArraySized.ArraySized range element)"},{"name":"repeat","comment":" A given amount of same elements\n\n    import N exposing (n4)\n\n    ArraySized.repeat 'L' n4\n    --: ArraySized\n    --:     (In (Up4 minX_) (Up4 maxX_))\n    --:     Char\n        |> ArraySized.toList\n    --> [ 'L', 'L', 'L', 'L' ]\n\n    ArraySized.repeat 'L' atLeast3\n    --: ArraySized (Min (Up3 x_)) Char\n\n","type":"element -> N.N range -> ArraySized.ArraySized range element"},{"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 range element -> ArraySized.ArraySized range element"},{"name":"take","comment":" A given number of elements\nto a given [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\n\nIt's easy if the minimum to take and the `ArraySized`'s minimum length match\n\n    import Linear exposing (Direction(..))\n    import N exposing (n7)\n\n    -- its three last elements\n    ArraySized.upTo n3AtLeast\n        |> ArraySized.take ( Down, n3 )\n\nIf the amount taken is greater than the `ArraySized`'s length minimum,\nadd `|> N.minTo currentLengthMinimum`\n\n    -- its first four elements\n    ArraySized.upTo between3And6\n        |> ArraySized.take ( Down, n4 |> N.minTo n3 )\n\nIf the amount taken is less than the `ArraySized`'s length minimum,\nadd `|> ArraySized.minTo takenMinimum`\n\n    ArraySized.l8 0 1 2 3 4 5 6 7\n        |> ArraySized.minTo n7\n        |> ArraySized.take ( Up, n7 )\n        --: ArraySized\n        --:     (In (Up7 minX_) (Up7 maxX_))\n        --:     number_\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.minTo n7\n        |> ArraySized.take ( Up, n7AtLeast )\n    --: ArraySized (Min (Up7 x_)) number_\n\n    ArraySized.l8 0 1 2 3 4 5 6 7\n        |> ArraySized.minTo n2\n        |> ArraySized.take ( Up, between2And7 )\n    --: ArraySized\n    --:     (In (Up2 minX_) (Up7 maxX_))\n    --:     number_\n\n","type":"( Linear.Direction, N.N (N.In min takenMax) ) -> ArraySized.ArraySized (N.In min max_) element -> ArraySized.ArraySized (N.In min takenMax) element"},{"name":"to1","comment":" Its only value\n\n    ArraySized.l1 \"hi\" |> ArraySized.to1\n    --> \"hi\"\n\n","type":"ArraySized.ArraySized (N.Exactly N.N1) element -> element"},{"name":"to10","comment":" Transform the `ArraySized` into a `Toop.T10`. This makes accessing elements and pattern matching easier.\n","type":"ArraySized.ArraySized (N.Exactly N.N10) element -> Toop.T10 element element element element element element element element element element"},{"name":"to11","comment":" Transform the `ArraySized` into a `Toop.T11`. This makes accessing elements and pattern matching easier.\n","type":"ArraySized.ArraySized (N.Exactly N.N11) element -> Toop.T11 element element element element element element element element element element element"},{"name":"to12","comment":" Transform the `ArraySized` into a `Toop.T12`. This makes accessing elements and pattern matching easier.\n","type":"ArraySized.ArraySized (N.Exactly N.N12) element -> Toop.T12 element element element element element element element element element element element element"},{"name":"to13","comment":" Transform the `ArraySized` into a `Toop.T13`. This makes accessing elements and pattern matching easier.\n","type":"ArraySized.ArraySized (N.Exactly N.N13) element -> Toop.T13 element element element element element element element element element element element element element"},{"name":"to14","comment":" Transform the `ArraySized` into a `Toop.T14`. This makes accessing elements and pattern matching easier.\n","type":"ArraySized.ArraySized (N.Exactly N.N14) element -> Toop.T14 element element element element element element element element element element element element element element"},{"name":"to15","comment":" Transform the `ArraySized` into a `Toop.T15`. This makes accessing elements and pattern matching easier.\n","type":"ArraySized.ArraySized (N.Exactly N.N15) element -> Toop.T15 element element element element element element element element element element element element element element element"},{"name":"to16","comment":" Transform the `ArraySized` into a `Toop.T16`. This makes accessing elements and pattern matching easier.\n","type":"ArraySized.ArraySized (N.Exactly N.N16) element -> Toop.T16 element element element element element element element element element element element element element element element element"},{"name":"to2","comment":" Transform the `ArraySized` into a `Toop.T2`. This makes accessing elements and pattern matching easier.\n","type":"ArraySized.ArraySized (N.Exactly N.N2) element -> Toop.T2 element element"},{"name":"to3","comment":" Transform the `ArraySized` into a `Toop.T3`. This makes accessing elements and pattern matching easier.\n","type":"ArraySized.ArraySized (N.Exactly N.N3) element -> Toop.T3 element element element"},{"name":"to4","comment":" Transform the `ArraySized` into a `Toop.T4`. This makes accessing elements and pattern matching easier.\n","type":"ArraySized.ArraySized (N.Exactly N.N4) element -> Toop.T4 element element element element"},{"name":"to5","comment":" Transform the `ArraySized` into a `Toop.T5`. This makes accessing elements and pattern matching easier.\n","type":"ArraySized.ArraySized (N.Exactly N.N5) element -> Toop.T5 element element element element element"},{"name":"to6","comment":" Transform the `ArraySized` into a `Toop.T6`. This makes accessing elements and pattern matching easier.\n","type":"ArraySized.ArraySized (N.Exactly N.N6) element -> Toop.T6 element element element element element element"},{"name":"to7","comment":" Transform the `ArraySized` into a `Toop.T7`. This makes accessing elements and pattern matching easier.\n","type":"ArraySized.ArraySized (N.Exactly N.N7) element -> Toop.T7 element element element element element element element"},{"name":"to8","comment":" Transform the `ArraySized` into a `Toop.T8`. This makes accessing elements and pattern matching easier.\n","type":"ArraySized.ArraySized (N.Exactly N.N8) element -> Toop.T8 element element element element element element element element"},{"name":"to9","comment":" Transform the `ArraySized` into a `Toop.T9`. This makes accessing elements and pattern matching easier.\n","type":"ArraySized.ArraySized (N.Exactly N.N9) element -> 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.upTo n4\n        |> ArraySized.map N.toInt\n        |> ArraySized.toArray\n    --> Array.fromList [ 0, 1, 2, 3, 4 ]\n\n","type":"ArraySized.ArraySized lengthRange_ element -> 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        --:         (In (Up0 minX_) (Up7 maxX_))\n        --:         (ArraySized\n        --:             (In (Up5 chunkMinX_) (Up5 chunkMaxX))\n        --:             number_\n        --:         )\n        --: , remainder :\n        --:     ArraySized\n        --:         (In\n        --:             (Up0 remainderMinX_)\n        --:             (Up4 chunkMaxX)\n        --:         )\n        --:         number_\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.Fixed (N.Add1 chunkMinMinus1)) (N.Up chunkMaxX N.To (N.Add1 chunkMaxMinus1PlusX))) -> ArraySized.ArraySized (N.In minLength_ max) element -> { chunks : ArraySized.ArraySized (N.In (N.Up0 minX_) max) (ArraySized.ArraySized (N.In (N.Fixed (N.Add1 chunkMinMinus1)) (N.Up chunkMaxX N.To (N.Add1 chunkMaxMinus1PlusX))) element), remainder : ArraySized.ArraySized (N.In (N.Up remainderMinX N.To remainderMinX) (N.Up chunkMaxX N.To chunkMaxMinus1PlusX)) element }"},{"name":"toEmptiable","comment":" On [`empty`](#empty) `Nothing`, on [`l1`](#l1) `Just` it's only value\n\nSadly, they way natural number constraints are defined,\nemptiness type information can't be transferred\n\n","type":"ArraySized.ArraySized (N.In min_ (N.Up maxToN1_ N.To N.N1)) element -> Emptiable.Emptiable element Possibly.Possibly"},{"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.upTo n4\n        |> ArraySized.map N.toInt\n        |> ArraySized.toList\n    --> [ 0, 1, 2, 3, 4 ]\n\n","type":"ArraySized.ArraySized lengthRange_ element -> List.List element"},{"name":"toStackEmptiable","comment":" Convert to an `Emptiable (Stacked ...) Possibly`.\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.l4 (0 |> Emptiable.filled) Emptiable.empty Emptiable.empty (3 |> Emptiable.filled)\n        |> ArraySized.fills\n        |> ArraySized.toStackEmptiable\n    --> Stack.topDown 0 [ 3 ]\n    --: Emptiable (Stacked Int) Possibly\n\nHave `>= 1` element? → Keep an `Emptiable ... never_` [`toStackFilled`](#toStackFilled)\n\n","type":"ArraySized.ArraySized lengthRange_ element -> Emptiable.Emptiable (Stack.Stacked element) Possibly.Possibly"},{"name":"toStackFilled","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 Stack\n\n    ArraySized.upTo n4\n        |> ArraySized.map N.toInt\n        |> ArraySized.toStackFilled\n    --> Stack.topDown 0 [ 1, 2, 3, 4 ]\n    --: Emptiable (Stacked Int) Never\n\nDon't have `>= 1` element? → [`toStackEmptiable`](#toStackEmptiable)\n\n","type":"ArraySized.ArraySized (N.In (N.Fixed (N.Add1 minMinus1_)) max_) element -> Emptiable.Emptiable (Stack.Stacked element) never_"},{"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.upTo n4\n        |> ArraySized.map\n            (\\n ->\n                ('a' |> Char.toCode)\n                    + (n |> N.toInt)\n                    |> Char.fromCode\n            )\n        |> ArraySized.toString\n    --> \"abcde\"\n\n","type":"ArraySized.ArraySized lengthRange_ Char.Char -> String.String"},{"name":"toValue","comment":" [`ArraySized`](#ArraySized) with a [`length`](#length)\nof [`Fixed` range](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#InFixed)\n→ equatable [`Value` range](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/N#InValue)\n","type":"ArraySized.ArraySized (N.InFixed min max) element -> ArraySized.ArraySized (N.InValue min max) element"},{"name":"upTo","comment":" Increasing natural numbers until including a given number\n\n    import N exposing (n3, n0)\n\n    ArraySized.upTo n3\n    --: ArraySized\n    --:     (In (Fixed N4) (Up4 maxX_))\n    --:     (N (In (Up0 minX_) (Up3 maxX_)))\n        |> ArraySized.map N.toInt\n        |> ArraySized.toList\n    --> [ 0, 1, 2, 3 ]\n\n    ArraySized.upTo n0\n    --: ArraySized\n    --:     (In (Fixed N1) (Up1 maxX_))\n    --:     (N (In (Up0 minX_) (Up0 maxX_)))\n        |> ArraySized.map N.toInt\n        |> ArraySized.toList\n    --> [ 0 ]\n\n    ArraySized.upTo between2And9\n        |> ArraySized.map (N.add n3)\n    --: ArraySized\n    --:    (In (Fixed N3) (Up10 maxX_))\n    --:    (N (In (Up5 minX_) (Up12 maxX_)))\n\nTo turn the `Fixed` length minimum into a difference (for results etc.)\n→ [`minTo`](#minTo)\n\n","type":"N.N (N.In (N.Fixed min) (N.Up maxX N.To maxPlusX)) -> ArraySized.ArraySized (N.In (N.Fixed (N.Add1 min)) (N.Up maxX N.To (N.Add1 maxPlusX))) (N.N (N.In (N.Up0 nMinX_) (N.Up maxX N.To maxPlusX)))"}],"binops":[]}]