[{"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 (Add1 minMinus1_) 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, upTo, random, fuzz, inFuzz\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, order\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\n\n## type-level\n\n@docs minTo, minDown\n@docs maxTo, maxToInfinity, maxUp\n\n\n## safe internals\n\nMostly useful for fancy extensions of [`ArraySized`](#ArraySized)\n\n@docs minToValue, minFromValue\n@docs maxToValue, maxFromValue\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[glueing](#combine), [taking, dropping, chunking](#part), [comparing](#length-compare), ...\n\n\n### argument type\n\n    -- length = 15\n    : ArraySized ... (Exactly N15)\n\n    -- length >= 4\n    : ArraySized ... (In (Fixed (Add4 minMinus4_)) max_)\n\n    -- 4 <= length <= 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    -- length >= 4\n    : ArraySized ... (Min (Fixed N4))\n\n    -- 4 <= length <= 15\n    : ArraySized ... (InFixed N4 N15)\n\n    -- length = 15\n    : ArraySized ... (Exactly N15)\n\n`InFixed`, `Exactly` are just shorthands exposed from `N`\n\n    InFixed min max =\n        In (Fixed min) (Fixed max)\n\n    Exactly n =\n        InFixed n n\n\n---\n\n`==` on both [`ArraySized`](#ArraySized)s and `N`s crashes elm.\n[Compare safely](#length-compare)\nor convert [`toValue`](#toValue)\n\n","args":["element","lengthRange"],"type":"ArraySized.Internal.ArraySized element lengthRange"}],"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 element lengthRange_ -> 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 (Emptiable.Emptiable value possiblyOrNever) range -> Emptiable.Emptiable (ArraySized.ArraySized value range) 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 nextElement range -> ArraySized.ArraySized element range -> ArraySized.ArraySized ( element, nextElement ) range"},{"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 element lengthRange_ -> 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 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? → [`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 element (N.In (N.Fixed min) (N.Up maxX N.To maxPlusX)) -> ArraySized.ArraySized element (N.In (N.Fixed takenMin) (N.Up maxX N.To takenMaxPlusX))"},{"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 element (N.In (N.Fixed min) max) -> ArraySized.ArraySized element (N.In (N.Fixed takenMin) max)"},{"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 element (N.In min_ (N.Fixed max)) -> ArraySized.ArraySized element (N.In (N.Up0 resultMinX_) (N.Fixed takenMax))"},{"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 element (N.In (N.Fixed (N.Add1 minMinus1)) 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":"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 element (N.In (N.Fixed (N.Add1 minMinus1)) (N.Up maxX N.To (N.Add1 maxMinus1PlusX))) -> ArraySized.ArraySized element (N.In (N.Fixed minMinus1) (N.Up maxX N.To maxMinus1PlusX))"},{"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 element (N.In (N.Fixed (N.Add1 minMinus1)) max) -> ArraySized.ArraySized element (N.In (N.Fixed minMinus1) max)"},{"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 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 element lengthRange_ -> Result.Result { indexBeyondElements : () } element"},{"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 (filled \"This\") Emptiable.empty (filled \"fine\")\n        |> ArraySized.fills\n        --: ArraySized String (In (Up0 minX_) (Up3 maxX_))\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 (Emptiable.Emptiable value possiblyOrNever_) (N.In (N.Fixed min_) max) -> ArraySized.ArraySized value (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.Fixed (N.Add1 minMinus1_)) 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 lengthRange_ -> 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 element (N.Min (N.Up0 x_))"},{"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 ... (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\nSadly, they way natural number constraints are defined,\n`possiblyOrNever` can't be transferred\n\n","type":"Emptiable.Emptiable element possiblyOrNever_ -> ArraySized.ArraySized element (N.In (N.Up0 minX_) (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.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 element (N.Min (N.Up0 x_))"},{"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\nGot an `Emptiable (Stacked ...) Never`? → [`fromStackFilled`](#fromStackFilled)\n\n","type":"Emptiable.Emptiable (Stack.Stacked element) possiblyOrNever_ -> ArraySized.ArraySized element (N.Min (N.Up0 x_))"},{"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 got an `Emptiable (Stacked ...) Possibly`? → [`fromStackEmptiable`](#fromStackEmptiable)\n\n","type":"Emptiable.Emptiable (Stack.Stacked element) Basics.Never -> ArraySized.ArraySized element (N.Min (N.Up1 x_))"},{"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 x_))\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":"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 element (N.InFixedValue min max) -> ArraySized.ArraySized element (N.InFixed min max)"},{"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":"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 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.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 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":"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 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":"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 comparedAgainstMinPlusXMinus1)) (N.Up maxX N.To (N.Add1 comparedAgainstMaxPlusXMinus1))) -> ArraySized.ArraySized element (N.In min max) -> Result.Result (N.BelowOrAbove (ArraySized.ArraySized element (N.In min (N.Up maxX N.To comparedAgainstMaxPlusXMinus1))) (ArraySized.ArraySized element (N.In (N.Up minX N.To (N.Add2 comparedAgainstMinPlusXMinus1)) max))) (ArraySized.ArraySized element (N.In (N.Up minX N.To (N.Add1 comparedAgainstMinPlusXMinus1)) (N.Up maxX N.To (N.Add1 comparedAgainstMaxPlusXMinus1))))"},{"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 lowerLimitMaxMinus1PlusX))) -> ArraySized.ArraySized element (N.In min max) -> Result.Result (ArraySized.ArraySized element (N.In min (N.Up lowerLimitMaxX N.To lowerLimitMaxMinus1PlusX))) (ArraySized.ArraySized element (N.In lowerLimitMin max))"},{"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 (Add3 minMinus3_) (Up maxTo50_ To N50))\n        -> (Metadata -> MetadataTagged)\n\n    tagIfValidTags :\n        ArraySized String (In (Add3 minMinus3_) 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 lowerLimitMaxPlusXMinus1))), 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 lowerLimitMaxPlusXMinus1))) (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.Fixed upperLimitMin) upperLimitMax) ) -> Fuzz.Fuzzer (ArraySized.ArraySized element (N.In lowerLimitMin upperLimitMax))"},{"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 Char (In (Fixed N4) (Up4 maxX_))\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 element (N.In (N.Fixed min) (N.Up maxX N.To maxPlusX)) -> ArraySized.ArraySized element (N.In (N.Fixed (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 (Fixed N6))\n\n    minCons :\n        element\n        -> ArraySized element (In (Fixed min) max_)\n        -> ArraySized element (Min (Fixed (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 `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 element (N.In (N.Fixed min) (N.Up x_ N.To maxPlusX_)) -> ArraySized.ArraySized element (N.Min (N.Fixed (N.Add1 min)))"},{"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 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 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\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":"l1","comment":" Create with only 1 single given element\n","type":"element -> ArraySized.ArraySized element (N.In (N.Up1 minX_) (N.Up1 maxX_))"},{"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.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 element range -> ArraySized.ArraySized mappedElement range"},{"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 element (N.In min (N.FixedValue max)) -> ArraySized.ArraySized element (N.In min (N.Fixed max))"},{"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 Field (Exactly N18)\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                Field\n                (In (Up20 minX_) (Up20 maxX_))\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 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":"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 element (N.In min (N.Fixed max)) -> ArraySized.ArraySized element (N.In min (N.FixedValue max))"},{"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 Char (In (Up4 minX_) (Up4 maxX_))\n        |> ArraySized.maxUp 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.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 element (N.In min (N.Up x N.To maxPlusX)) -> ArraySized.ArraySized element (N.In min (N.Up x N.To maxIncreasedPlusX))"},{"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 Char (In (Up4 minX_) (Up4 maxX_))\n        |> ArraySized.minDown 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.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 element (N.In (N.Up x N.To minPlusX) max) -> ArraySized.ArraySized element (N.In (N.Up x N.To minDecreasedPlusX) max)"},{"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 element (N.In (N.FixedValue min) max) -> ArraySized.ArraySized element (N.In (N.Fixed min) max)"},{"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 Field (Exactly N18)\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                Field\n                (In (Up20 minX_) (Up20 maxX_))\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 element (N.In (N.Fixed min) max) -> ArraySized.ArraySized element (N.In minNew max)"},{"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 element (N.In (N.Fixed min) max) -> ArraySized.ArraySized element (N.In (N.FixedValue min) max)"},{"name":"order","comment":" [`Order`](https://dark.elm.dmy.fr/packages/lue-bird/elm-linear-direction/latest/Order)\n2 [`ArraySized`](#ArraySized)s by elements first to last\n\n    import Order\n\n    ArraySized.order Order.int\n        (ArraySized.l4 11 22 33 188)\n        (ArraySized.l3 11 22 34)\n    --> LT\n\n","type":"Order.Ordering element -> ArraySized.ArraySized element length0_ -> ArraySized.ArraySized element length1_ -> Basics.Order"},{"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 Bit (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 element (N.In (N.Fixed paddingMin) (N.Up maxX N.To paddingMaxPlusX))) -> N.N (N.In (N.Fixed paddedMin) (N.Up maxX N.To paddedMaxPlusX)) -> ArraySized.ArraySized element (N.In (N.Up paddingMaxPlusX N.To paddedMaxPlusX) (N.Up paddingMin N.To paddedMin)) -> ArraySized.ArraySized element (N.In (N.Fixed paddedMin) (N.Up maxX N.To paddedMaxPlusX))"},{"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) (N.Up maxX_ N.To maxPlusX_)) -> 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 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 element range)"},{"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\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 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.minTo n7\n        |> ArraySized.take ( Up, n7AtLeast )\n    --: ArraySized number_ (Min (Up7 x_))\n\n    ArraySized.l8 0 1 2 3 4 5 6 7\n        |> ArraySized.minTo n2\n        |> ArraySized.take ( Up, between2And7 )\n    --: ArraySized number_ (In (Up2 minX_) (Up7 maxX_))\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":"to1","comment":" Its only value\n\n    ArraySized.l1 \"hi\" |> ArraySized.to1\n    --> \"hi\"\n\n","type":"ArraySized.ArraySized element (N.Exactly N.N1) -> element"},{"name":"to10","comment":" Transform into a `Toop.T10` to simplify accessing elements, pattern matching\n","type":"ArraySized.ArraySized element (N.Exactly 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.Exactly 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.Exactly 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.Exactly 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.Exactly 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.Exactly 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.Exactly 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.Exactly 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.Exactly 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.Exactly 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.Exactly 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.Exactly 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.Exactly 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.Exactly 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.Exactly 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.upTo n4\n        |> ArraySized.map N.toInt\n        |> ArraySized.toArray\n    --> Array.fromList [ 0, 1, 2, 3, 4 ]\n\n","type":"ArraySized.ArraySized element lengthRange_ -> 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.Fixed (N.Add1 chunkMinMinus1)) (N.Up chunkMaxX N.To (N.Add1 chunkMaxMinus1PlusX))) -> ArraySized.ArraySized element (N.In minLength_ max) -> { chunks : ArraySized.ArraySized (ArraySized.ArraySized element (N.In (N.Fixed (N.Add1 chunkMinMinus1)) (N.Up chunkMaxX N.To (N.Add1 chunkMaxMinus1PlusX)))) (N.In (N.Up0 minX_) max), remainder : ArraySized.ArraySized element (N.In (N.Up remainderMinX N.To remainderMinX) (N.Up chunkMaxX N.To chunkMaxMinus1PlusX)) }"},{"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 element (N.In min_ (N.Up maxToN1_ N.To N.N1)) -> 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 element lengthRange_ -> 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 element lengthRange_ -> 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 element (N.In (N.Fixed (N.Add1 minMinus1_)) max_) -> 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 Char.Char lengthRange_ -> 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 element (N.InFixed min max) -> ArraySized.ArraySized element (N.InFixedValue min max)"},{"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    --:     (N (In (Up0 minX_) (Up3 maxX_)))\n    --:     (In (Fixed N4) (Up4 maxX_))\n        |> ArraySized.map N.toInt\n        |> ArraySized.toList\n    --> [ 0, 1, 2, 3 ]\n\n    ArraySized.upTo n0\n    --: ArraySized\n    --:     (N (In (Up0 minX_) (Up0 maxX_)))\n    --:     (In (Fixed N1) (Up1 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    --:    (N (In (Up5 minX_) (Up12 maxX_)))\n    --:    (In (Fixed N3) (Up10 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.N (N.In (N.Up0 nMinX_) (N.Up maxX N.To maxPlusX))) (N.In (N.Fixed (N.Add1 min)) (N.Up maxX N.To (N.Add1 maxPlusX)))"}],"binops":[]}]