[{"name":"ArraySized","comment":" An `ArraySized` describes an array where you know more about the amount of elements.\n\n    import Linear exposing (DirectionLinear(..))\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? Let's look at an example:\n\n> You have an array of 1+ elements. Get us the 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    withArr : ArraySized (In (Add1 minMinus1_) max_) comparable -> comparable\n    withArr =\n        ArraySized.fold Up max\n\nThe `Array` type doesn't give us the info that it contains 1+ elements.\n[`ArraySized`](#ArraySized) simply knows more about the length at compile time,\nso we can [`fold`](#fold) without a worry for example.\n\n@docs ArraySized, In\n\n\n# create\n\n@docs fromArray, fromList, fromEmptiable, repeat, random, until\n\n\n## specific\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<x>` with `x >= 17` locally](https://lue-bird.github.io/elm-typesafe-array/generate/),\nput them in a `module exposing (l<x>)` + `import as ArraySized`\n\n\n# scan\n\n@docs length\n@docs element, to1\n@docs areAll, isAny\n\n\n# alter\n\n@docs elementReplace, elementAlter, reverse\n@docs push, minPush, elementRemove, minElementRemove, insert, minInsert\n@docs intersperseIn, intersperseAtLeast\n\n\n## filter\n\n@docs fills, areAllFilled\n\n\n## part\n\n@docs drop, minDrop\n@docs take, takeAtMost\n@docs toChunksOf\n\n\n## glueing\n\n@docs glue, glueIn, glueAtLeast\n\n\n# length compare\n\n@docs hasIn, has, hasAtLeast, hasAtMost\n\n\n# transform\n\n@docs map, foldFrom, fold, toArray, toList, toEmptiable\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## type information\n\n@docs minLower, maxOpen, noMax, maxUp\n\n","unions":[],"aliases":[{"name":"ArraySized","comment":" An `Array` where you know more about the amount of elements.\n\n\n## result type\n\n    -- amount >= 5\n    : ArraySized (Min N5) ...\n\n    -- 2 <= amount <= 12\n    : ArraySized (In N2 (Add12 a_)) ...\n\n\n### argument type\n\n    -- = 15\n    : ArraySized (Exactly N15) ...\n\n    -- amount >= 4\n    : ArraySized (In (Add4 minMinus4_) max_) ...\n\n    -- 4 <= amount <= 15\n    : ArraySized (In (Add4 minMinus4_) N15) ...\n\n\n## stored type\n\nin your `Model` for example (which means: no type variables)\n\n    -- = 15\n    : ArraySized (Exactly N15) ...\n\n    -- amount >= 4\n    : ArraySized (Min N4) ...\n\n    -- 4 <= amount <= 15\n    : ArraySized (In N4 N15) ...\n\n`==` crashes elm. Try [other comparison methods](#length-compare)\n\n","args":["length","element"],"type":"ArraySized.Internal.ArraySized length element"},{"name":"In","comment":" [`ArraySized`](#ArraySized) length ranges are set up to not include [differences](https://dark.elm.dmy.fr/packages/lue-bird/elm-bounded-nat/latest/N#Is)\nas the specific `N` values `n0`, `n1`, ... do.\n\nIf you prefer to just use one type for both [`N`](https://dark.elm.dmy.fr/packages/lue-bird/elm-bounded-nat/latest/N#N) and [`ArraySized`](#ArraySized)\n\n    import N exposing (In)\n    In min max {}\n\nnobody's stopping you :)\n\n","args":["min","max"],"type":"N.In min max {}"}],"values":[{"name":"areAll","comment":" Whether all elements satisfy a test.\n\n    ArraySized.l2 2 3 |> ArraySized.areAll (\\n -> n <= 4)\n    --> True\n\n    ArraySized.l2 2 7 |> ArraySized.areAll (\\n -> n <= 4)\n    --> False\n\n    ArraySized.empty |> ArraySized.areAll (\\n -> n <= 4)\n    --> True\n\n","type":"(element -> Basics.Bool) -> ArraySized.ArraySized length_ element -> Basics.Bool"},{"name":"areAllFilled","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.areAllFilled\n        |> fillMap ArraySized.toList\n    --> filled []\n\n    ArraySized.l3 (filled 1) (filled 2) (filled 3)\n        |> ArraySized.areAllFilled\n        |> fillMap ArraySized.toList\n    --> filled [ 1, 2, 3 ]\n\n    ArraySized.l3 (filled 1) Emptiable.empty (filled 3)\n        |> ArraySized.areAllFilled\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.areAllFilled\n\n    -- vs\n    groupCall =\n        map5 Toop.T5\n            aUser.phoneNumber\n            bUser.phoneNumber\n            cUser.phoneNumber\n            dUser.phoneNumber\n            eUser.phoneNumber\n\n","type":"ArraySized.ArraySized length (Emptiable.Emptiable value possiblyOrNever) -> Emptiable.Emptiable (ArraySized.ArraySized length value) possiblyOrNever"},{"name":"drop","comment":" Elements after a certain number of elements in a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/).\n\n    import Linear exposing (DirectionLinear(..))\n    import N exposing (n2)\n\n    ArraySized.l4 0 1 2 3\n        |> ArraySized.drop Down n2\n        --: ArraySized (In N2 (Add2 a_)) number_\n        |> ArraySized.toList\n    --> [ 0, 1 ]\n\n    between6And10Elements\n        |> ArraySized.drop Up n2\n    --: ArraySized (In N4 (Add10 a_)) ...\n\n","type":"Linear.DirectionLinear -> N.N (N.In dropped_ droppedAtLeast_ (N.Is (N.Diff minTaken N.To min) (N.Diff maxTaken N.To max))) -> ArraySized.ArraySized (ArraySized.In min max) element -> ArraySized.ArraySized (ArraySized.In minTaken maxTaken) element"},{"name":"element","comment":" The element at a valid position in a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/).\n\n    import Linear exposing (DirectionLinear(..))\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.DirectionLinear, N.N (N.In indexMin_ minLengthMinus1 indexDifference_) ) -> ArraySized.ArraySized (ArraySized.In (N.Add1 minLengthMinus1) maxLength_) element -> element"},{"name":"elementAlter","comment":" Change the element at an index in a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/) based on its previous value.\n\n    import Linear exposing (DirectionLinear(..))\n    import N exposing (n0)\n\n    ArraySized.l3 1 20 30\n        |> ArraySized.elementAlter ( Up, n0 ) (\\x -> x * 10)\n        --: ArraySized (In n3 (Add3 a)) number_\n        |> ArraySized.toList\n    --> [ 10, 20, 30 ]\n\n    ArraySized.l3 1 20 30\n        |> ArraySized.elementAlter ( Down, n0 ) (\\x -> -x)\n        --: ArraySized (In n3 (Add3 a)) number_\n        |> ArraySized.toList\n    --> [ 1, 20, -30 ]\n\nAn index that's out of bounds is ignored.\n\n    import Linear exposing (DirectionLinear(..))\n    import N exposing (n3)\n\n    ArraySized.l3 1 20 30\n        |> ArraySized.elementAlter ( Up, n3 ) (\\x -> x * 10)\n        --: ArraySized (In n3 (Add3 a)) number_\n        |> ArraySized.toList\n    --> [ 1, 20, 30 ]\n\n","type":"( Linear.DirectionLinear, N.N index_ ) -> (element -> element) -> ArraySized.ArraySized length element -> ArraySized.ArraySized length element"},{"name":"elementRemove","comment":" Kick an element out of the `ArraySized`\nat a given index in a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\n\n    import Linear exposing (DirectionLinear(..))\n    import N exposing (n5)\n\n    removeLast between1And10Elements =\n        between1And10Elements\n            |> ArraySized.elementRemove ( Down, n0 )\n\n","type":"( Linear.DirectionLinear, N.N (N.In indexMin_ minLengthMinus1 indexDifference_) ) -> ArraySized.ArraySized (ArraySized.In (N.Add1 minLengthMinus1) (N.Add1 maxLengthMinus1)) element -> ArraySized.ArraySized (ArraySized.In minLengthMinus1 maxLengthMinus1) element"},{"name":"elementReplace","comment":" Set the element at an index in a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/).\n\n    import Linear exposing (DirectionLinear(..))\n    import N exposing (n1, n2)\n\n    ArraySized.l3 \"I\" \"am\" \"ok\"\n        |> ArraySized.elementReplace ( Up, n2 )\n            (\\() -> \"confusion\")\n        --: ArraySized (In n3 (Add3 a)) String\n        |> ArraySized.toList\n    --> [ \"I\", \"am\", \"confusion\" ]\n\n    ArraySized.l3 \"I\" \"am\" \"ok\"\n        |> ArraySized.elementReplace ( Down, n1 )\n            (\\() -> \"feel\")\n        --: ArraySized (In n3 (Add3 a)) String\n        |> ArraySized.toList\n    --> [ \"I\", \"feel\", \"ok\" ]\n\nAn index that's out of bounds is ignored\nand the element replacement is never evaluated.\n\n    import Linear exposing (DirectionLinear(..))\n    import N exposing (n3)\n\n    ArraySized.l3 \"I\" \"am\" \"ok\"\n        |> ArraySized.elementReplace ( Down, n3 )\n            (\\() -> \"feel\")\n        --: ArraySized (In n3 (Add3 a)) String\n        |> ArraySized.toList\n    --> [ \"I\", \"am\", \"ok\" ]\n\n","type":"( Linear.DirectionLinear, N.N index_ ) -> (() -> element) -> ArraySized.ArraySized length element -> ArraySized.ArraySized length element"},{"name":"empty","comment":" No elements\n\n    ArraySized.empty\n    --: ArraySized (In N0 atLeast0_) element\n        |> ArraySized.push \":)\"\n    --: ArraySized (In N1 (Add1 atLeast0_)) String\n\n","type":"ArraySized.ArraySized (ArraySized.In N.N0 atLeast0_) element_"},{"name":"fills","comment":" Take every `filled value`, drop every `empty`.\n\n    import N exposing (n0)\n    import Emptiable exposing (filled)\n\n    ArraySized.l3 (filled \"This\") Emptiable.empty (filled \"fine\")\n        |> ArraySized.fills\n        --: ArraySized (In N0 (Add3 a_)) 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 N exposing (n0)\n\n    ArraySized.l3 \"1.2\" \"2\" \"hello\"\n        |> ArraySized.map (String.toInt >> Emptiable.fromMaybe)\n        |> ArraySized.fills\n        --: ArraySized (In N0 (Add3 a_)) Int\n        |> ArraySized.toList\n    --> [ 2 ]\n\n","type":"ArraySized.ArraySized (ArraySized.In min_ max) (Emptiable.Emptiable value possiblyOrNever_) -> ArraySized.ArraySized (ArraySized.In N.N0 max) value"},{"name":"fold","comment":" A fold in a [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 (DirectionLinear(..))\n\n    ArraySized.l3 234 345 543\n        |> ArraySized.fold Up 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.DirectionLinear -> (element -> element -> element) -> ArraySized.ArraySized (ArraySized.In (N.Add1 minLengthMinus1_) maxLength_) element -> element"},{"name":"foldFrom","comment":" Reduce an `ArraySized` in a [direction](https://package.elm-lang.org/packages/indique/elm-linear-direction/latest/).\n\n    import Linear exposing (DirectionLinear(..))\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.DirectionLinear -> (element -> result -> result) -> ArraySized.ArraySized length_ element -> result"},{"name":"fromArray","comment":" Create from an `Array`.\nAs every `Array` has `>= 0` elements:\n\n    arrayFromSomeOtherLibrary |> ArraySized.fromArray\n    --: ArraySized (Min N0)\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.until 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.N0) 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 (In N0 (Add1 a_))\n        |> ArraySized.toList\n    --> [ \"hi\" ]\n\n    Emptiable.empty\n        |> ArraySized.fromEmptiable\n        --: ArraySized (In N0 (Add1 a_))\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 (ArraySized.In N.N0 (N.Add1 a_)) element"},{"name":"fromList","comment":" Create from a `List`.\nAs every `List` has `>= 0` elements:\n\n    listFromSomeOtherLibrary |> ArraySized.fromList\n    --: ArraySized (Min N0)\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.up n7 -- 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.N0) 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 (DirectionLinear(..))\n    import N exposing (n3)\n\n    ArraySized.l3 1 2 3\n        |> ArraySized.glue Up n3 (ArraySized.l3 4 5 6)\n        --: ArraySized (In n6 (Add6 a_)) number_\n        |> ArraySized.toList\n    --> [ 1, 2, 3, 4, 5, 6 ]\n\n    ArraySized.l3 1 2 3\n        |> ArraySized.glue Down n3 (ArraySized.l3 4 5 6)\n        --: ArraySized (In n6 (Add6 a_)) number_\n        |> ArraySized.toList\n    --> [ 4, 5, 6, 1, 2, 3 ]\n\n","type":"Linear.DirectionLinear -> N.N (N.In added atLeastAdded_ (N.Is (N.Diff min N.To minLengthSum) (N.Diff max N.To minSumMax))) -> ArraySized.ArraySized (N.Exactly added) element -> ArraySized.ArraySized (ArraySized.In min max) element -> ArraySized.ArraySized (ArraySized.In minLengthSum minSumMax) element"},{"name":"glueAtLeast","comment":" Attach elements of an `ArraySized` to a given [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/).\n\n    ArraySized.l3 1 2 3\n        |> ArraySized.glueAtLeast Up n3 atLeast3Elements\n    --: ArraySized (Min N6) ...\n\n    ArraySized.l3 1 2 3\n        |> ArraySized.glueAtLeast Down n3 atLeast3Elements\n    --: ArraySized (Min N6) ...\n\n","type":"Linear.DirectionLinear -> N.N (N.In minAdded atLeastMinAdded_ (N.Is (N.Diff min N.To minLengthSum) is_)) -> ArraySized.ArraySized (ArraySized.In minAdded maxAdded_) element -> ArraySized.ArraySized (ArraySized.In min maxLength_) element -> ArraySized.ArraySized (N.Min minLengthSum) element"},{"name":"glueIn","comment":" Attach elements of an `ArraySized` which has multiple possible amounts to a given [direction](https://dark.elm.dmy.fr/packages/lue-bird/elm-linear-direction/latest/).\n\n    import Linear exposing (DirectionLinear(..))\n    import N exposing (n3, n5)\n\n    ArraySized.l3 1 2 3\n        |> ArraySized.glueIn Up\n            ( n3, n5 )\n            between3And5Elements\n    --: ArraySized (In N6 (Add8 a))\n\n    ArraySized.l3 1 2 3\n        |> ArraySized.glueIn Down\n            ( n3, n5 )\n            between3And5Elements\n    --: ArraySized (In N6 (Add8 a))\n\nUse [`glue`](#glue) to glue an `Exact` amount of elements.\n\n","type":"Linear.DirectionLinear -> ( N.N (N.In addedMin atLeastAddedMin_ (N.Is (N.Diff min N.To minLengthSum) addedMinDiff1_)), N.N (N.In addedMax atLeastAddedMax_ (N.Is addedMaxDiff0_ (N.Diff max N.To maxLengthSum))) ) -> ArraySized.ArraySized (ArraySized.In addedMin addedMax) element -> ArraySized.ArraySized (ArraySized.In min max) element -> ArraySized.ArraySized (ArraySized.In minLengthSum maxLengthSum) 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 comparedAgainstMin (N.Add1 comparedAgainstMaxMinus1) comparedAgainstDifference) -> ArraySized.ArraySized (ArraySized.In min max) element -> Result.Result (N.BelowOrAbove (ArraySized.ArraySized (ArraySized.In min comparedAgainstMaxMinus1) element) (ArraySized.ArraySized (ArraySized.In (N.Add1 comparedAgainstMin) max) element)) (ArraySized.ArraySized (ArraySized.In comparedAgainstMin (N.Add1 comparedAgainstMaxMinus1)) element)"},{"name":"hasAtLeast","comment":" Is its length below (`Err`) or atLeast (`Ok`) as big as a given `N`?\n\n    import N exposing (n5)\n\n    first5 :\n        ArraySized (In minLength_ max) element\n        -> Maybe (ArraySized (In N5 max) element)\n    first5 arraySized =\n        case arraySized |> ArraySized.hasAtLeast n5 of\n            N.Below _ ->\n                Nothing\n\n            N.EqualOrGreater atLeast5 ->\n                Just atLeast5\n\n","type":"N.N (N.In lowerLimitMin (N.Add1 lowerLimitMaxMinus1) lowerLimitDifference_) -> ArraySized.ArraySized (ArraySized.In min max) element -> Result.Result (ArraySized.ArraySized (ArraySized.In min lowerLimitMaxMinus1) element) (ArraySized.ArraySized (ArraySized.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 orHigherMin_) N50) String\n        -> a\n        -> Tagged a\n\n    tagIfValidTags :\n        ArraySized (In (Add3 orHigherMin_) max)\n        -> a\n        -> Maybe (Tagged a)\n    tagIfValidTags array value =\n        case\n            array\n                |> ArraySized.fromArray\n                |> ArraySized.hasAtMost n50\n        of\n            Ok atMost53 ->\n                tag value atMost53 |> Just\n\n            Err _ ->\n                Nothing\n\n","type":"N.N (N.In upperLimitMin upperLimitMax upperLimitDifference_) -> ArraySized.ArraySized (ArraySized.In min max) element -> Result.Result (ArraySized.ArraySized (ArraySized.In (N.Add1 upperLimitMin) max) element) (ArraySized.ArraySized (ArraySized.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.Add1 lowerLimitMaxMinus1) lowerLimitDifference_), N.N (N.In upperLimitMin upperLimitMax upperLimitDifference_) ) -> ArraySized.ArraySized (ArraySized.In min max) element -> Result.Result (N.BelowOrAbove (ArraySized.ArraySized (ArraySized.In min lowerLimitMaxMinus1) element) (ArraySized.ArraySized (ArraySized.In (N.Add1 upperLimitMin) max) element)) (ArraySized.ArraySized (ArraySized.In lowerLimitMin upperLimitMax) element)"},{"name":"insert","comment":" Put an element in the `ArraySized` at a given index\nin a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\n\n    import Linear exposing (DirectionLinear(..))\n    import N exposing (n1, n2)\n\n    ArraySized.l3 'a' 'c' 'd'\n        |> ArraySized.insert ( Up, n1 ) 'b'\n        --: ArraySized (In N4 (Add4 a_)) Char\n        |> ArraySized.toList\n    --> [ 'a', 'b', 'c', 'd' ]\n\n    ArraySized.l3 'a' 'c' 'd'\n        |> ArraySized.insert ( Down, n2 ) 'b'\n        --: ArraySized (In N4 (Add4 a_)) Char\n        |> ArraySized.toList\n    --> [ 'a', 'b', 'c', 'd' ]\n\n","type":"( Linear.DirectionLinear, N.N (N.In indexMin_ min indexDifference_) ) -> element -> ArraySized.ArraySized (ArraySized.In min max) element -> ArraySized.ArraySized (ArraySized.In (N.Add1 min) (N.Add1 max)) element"},{"name":"intersperseAtLeast","comment":" Place a value between all members.\n\nTo get the correct final length type, we need to give the current minimum length as an arguments.\n\n    import N exposing (n3)\n\n    atLeast3Turtles\n        |> ArraySized.intersperseAtLeast n3 \"on\"\n    --→ \"turtles\" \"on\" \"turtles\" \"on\" \"turtles\" ...\n    --: ArraySized (Min N5) String\n\n","type":"N.N (N.In min minAtLeast_ (N.Is (N.Diff min N.To (N.Add1 minDoubleMinus1)) minDiff1_)) -> element -> ArraySized.ArraySized (ArraySized.In min maxLength_) element -> ArraySized.ArraySized (N.Min minDoubleMinus1) element"},{"name":"intersperseIn","comment":" Place a value between all members.\n\nTo get the correct final length type,\nwe need to give the current `(` minimum `,` maximum `)` length as an arguments.\n\n    import N exposing (n3)\n\n    ArraySized.l3 \"turtles\" \"turtles\" \"turtles\"\n        |> ArraySized.intersperseIn ( n3, n3 ) \"on\"\n        --: ArraySized (In N5 (Add5 a_)) String\n        |> ArraySized.toList\n    --> [ \"turtles\", \"on\", \"turtles\", \"on\", \"turtles\" ]\n\n","type":"( N.N (N.In min atLeastMinLength_ (N.Is (N.Diff min N.To (N.Add1 minDoubleLengthMinus1)) minDiff1_)), N.N (N.In max atLeastMaxLength_ (N.Is maxDiff0_ (N.Diff max N.To (N.Add1 maxDoubleLengthMinus1)))) ) -> element -> ArraySized.ArraySized (ArraySized.In min max) element -> ArraySized.ArraySized (ArraySized.In minDoubleLengthMinus1 maxDoubleLengthMinus1) element"},{"name":"isAny","comment":" Whether any elements satisfy a test.\n\n    ArraySized.l2 300 -5 |> ArraySized.isAny (\\n -> n <= 4)\n    --> True\n\n    ArraySized.l2 5 5 |> ArraySized.isAny (\\n -> n <= 4)\n    --> False\n\n    ArraySized.empty |> ArraySized.isAny (\\n -> n <= 4)\n    --> False\n\n","type":"(element -> Basics.Bool) -> ArraySized.ArraySized length_ element -> Basics.Bool"},{"name":"l1","comment":" Create an `ArraySized` with exactly 1 element\n","type":"element -> ArraySized.ArraySized (ArraySized.In N.N1 (N.Add1 a_)) element"},{"name":"l10","comment":" Create an `ArraySized` with exactly 10 elements in this order\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> ArraySized.ArraySized (ArraySized.In N.N10 (N.Add10 a_)) element"},{"name":"l11","comment":" Create an `ArraySized` with exactly 11 elements in this order\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> ArraySized.ArraySized (ArraySized.In N.N11 (N.Add11 a_)) element"},{"name":"l12","comment":" Create an `ArraySized` with exactly 12 elements in this order\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> ArraySized.ArraySized (ArraySized.In N.N12 (N.Add12 a_)) element"},{"name":"l13","comment":" Create an `ArraySized` with exactly 13 elements in this order\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> ArraySized.ArraySized (ArraySized.In N.N13 (N.Add13 a_)) element"},{"name":"l14","comment":" Create an `ArraySized` with exactly 14 elements in this order\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> ArraySized.ArraySized (ArraySized.In N.N14 (N.Add14 a_)) element"},{"name":"l15","comment":" Create an `ArraySized` with exactly 15 elements in this order\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> ArraySized.ArraySized (ArraySized.In N.N15 (N.Add15 a_)) element"},{"name":"l16","comment":" Create an `ArraySized` with exactly 16 elements in this order\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> ArraySized.ArraySized (ArraySized.In N.N16 (N.Add16 a_)) element"},{"name":"l2","comment":" Create an `ArraySized` with exactly 2 elements in this order\n","type":"element -> element -> ArraySized.ArraySized (ArraySized.In N.N2 (N.Add2 a_)) element"},{"name":"l3","comment":" Create an `ArraySized` with exactly 3 elements in this order\n","type":"element -> element -> element -> ArraySized.ArraySized (ArraySized.In N.N3 (N.Add3 a_)) element"},{"name":"l4","comment":" Create an `ArraySized` with exactly 4 elements in this order\n","type":"element -> element -> element -> element -> ArraySized.ArraySized (ArraySized.In N.N4 (N.Add4 a_)) element"},{"name":"l5","comment":" Create an `ArraySized` with exactly 5 elements in this order\n","type":"element -> element -> element -> element -> element -> ArraySized.ArraySized (ArraySized.In N.N5 (N.Add5 a_)) element"},{"name":"l6","comment":" Create an `ArraySized` with exactly 6 elements in this order\n","type":"element -> element -> element -> element -> element -> element -> ArraySized.ArraySized (ArraySized.In N.N6 (N.Add6 a_)) element"},{"name":"l7","comment":" Create an `ArraySized` with exactly 7 elements in this order\n","type":"element -> element -> element -> element -> element -> element -> element -> ArraySized.ArraySized (ArraySized.In N.N7 (N.Add7 a_)) element"},{"name":"l8","comment":" Create an `ArraySized` with exactly 8 elements in this order\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> ArraySized.ArraySized (ArraySized.In N.N8 (N.Add8 a_)) element"},{"name":"l9","comment":" Create an `ArraySized` with exactly 9 elements in this order\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> ArraySized.ArraySized (ArraySized.In N.N9 (N.Add9 a_)) element"},{"name":"length","comment":" The amount of elements.\n\n    import N exposing (n3)\n\n    ArraySized.l3 1 2 3\n        |> ArraySized.length\n        --: N (N.In N3 (Add3 a_))\n        |> N.toInt\n    --> 3\n\n    between3And5Elements |> ArraySized.length\n    --: N (N.In N3 (Add5 a_))\n\n    atLeast3Elements |> ArraySized.length\n    --: N (Min N3)\n\n","type":"ArraySized.ArraySized length element_ -> N.N length"},{"name":"map","comment":" Change every element.\n\n    import N exposing (n25)\n\n    aToZ : ArraySized (In N26 (N26Plus a_)) Char\n    aToZ =\n        ArraySized.until 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 length element -> ArraySized.ArraySized length mappedElement"},{"name":"maxOpen","comment":" Make an `ArraySized` with a fixed maximum length fit into functions with require a higher maximum length.\n\nDesigning argument and stored types as broad as possible:\n\n    atMost18Elements : ArraySized (In min_ N18) ...\n\nThe argument in `atMost18Elements` should also fit in `atMost19Elements` for example\n\n    atMost19Elements theArgument -- error\n\n    atMost19Elements (theArgument |> ArraySized.maxOpen n18)\n\n","type":"N.N (N.In max newMax difference_) -> ArraySized.ArraySized (ArraySized.In min max) element -> ArraySized.ArraySized (ArraySized.In min newMax) element"},{"name":"maxUp","comment":" Have a specific maximum in mind? → [`maxOpen`](#maximum)\n\nWant to increase the upper bound by a fixed amount? ↓\n\n    maxUp4 : ArraySized (In min max) -> ArraySized (In min (Add4 max))\n    maxUp4 =\n        ArraySized.maxUp n4\n\nWhen is this useful? Very rarely, to preserve type variables.\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 increase_ increaseAtLeast_ (N.Is (N.Diff max N.To maxIncreased) diff1_)) -> ArraySized.ArraySized (ArraySized.In min max) element -> ArraySized.ArraySized (ArraySized.In min maxIncreased) element"},{"name":"minDrop","comment":" Elements after a certain number of elements in a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/).\n\n    import Linear exposing (DirectionLinear(..))\n    import N exposing (n2)\n\n    atLeast6Elements\n        |> ArraySized.minDrop Down n2\n    --: ArraySized (Min N4) ...\n\n","type":"Linear.DirectionLinear -> N.N (N.In dropped_ atLeastDropped_ (N.Is (N.Diff minTaken N.To min) is_)) -> ArraySized.ArraySized (ArraySized.In min max) element -> ArraySized.ArraySized (ArraySized.In minTaken max) element"},{"name":"minElementRemove","comment":" Kick out the element at an index in a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/).\n\n    removeLast =\n        TypeSized.minElementRemove ( Down, n0 )\n\n","type":"( Linear.DirectionLinear, N.N (N.In indexMin_ minLengthMinus1 indexDifference_) ) -> ArraySized.ArraySized (ArraySized.In (N.Add1 minLengthMinus1) max) element -> ArraySized.ArraySized (ArraySized.In minLengthMinus1 max) element"},{"name":"minInsert","comment":" Put a new element at an index in a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/).\n\n    import Linear exposing (DirectionLinear(..))\n    import N exposing (n0, n1)\n\n    atLeast5Elements\n        |> ArraySized.minInsert ( Down, n1 )\n            \"before last\"\n    --: ArraySized (Min N6) String\n\n    cons :\n        element\n        -> ArraySized (In min maxLength_) element\n        -> ArraySized (Min (Add1 min)) element\n    cons =\n        ArraySized.minInsert ( Up, n0 )\n\n","type":"( Linear.DirectionLinear, N.N (N.In indexMin_ min indexDifference_) ) -> element -> ArraySized.ArraySized (ArraySized.In min maxLength_) element -> ArraySized.ArraySized (N.Min (N.Add1 min)) element"},{"name":"minLower","comment":" Use a lower minimum length in the type.\n\n    [ atLeast3Elements\n    , atLeast4Elements\n    ]\n\nelm complains that\n\n> all the previous elements in the list are `ArraySized (Min N3) ...`\n\n    [ atLeast3Elements\n    , atLeast4Elements\n        |> ArraySized.minDownLength n3\n    ]\n\n","type":"N.N (N.In newMinLength min newMinDifference_) -> ArraySized.ArraySized (ArraySized.In min max) element -> ArraySized.ArraySized (ArraySized.In newMinLength max) element"},{"name":"minPush","comment":" Put a new element after the others.\n\n    atLeast5Elements\n        |> ArraySized.minPush \"becomes the last\"\n    --: ArraySized (Min N6) String\n\n","type":"element -> ArraySized.ArraySized (ArraySized.In min maxLength_) element -> ArraySized.ArraySized (N.Min (N.Add1 min)) element"},{"name":"noMax","comment":" Convert the `ArraySized (In min ...)` to a `ArraySized (Min min)`.\n\n    between4And10Elements |> ArraySized.toMin\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.toMin\n    ]\n\n","type":"ArraySized.ArraySized (ArraySized.In min max_) element -> ArraySized.ArraySized (N.Min min) element"},{"name":"push","comment":" Equivalent to `insert n0 Down`. Put a new element after all the others.\n\n    between5And10Elements\n        |> ArraySized.push \"becomes the last\"\n    --: ArraySized (In N6 (Add11 a_)) String\n\n","type":"element -> ArraySized.ArraySized (ArraySized.In min max) element -> ArraySized.ArraySized (ArraySized.In (N.Add1 min) (N.Add1 max)) element"},{"name":"random","comment":" `Random.Generator` for a given amount of elements.\n\n    import N exposing (n5)\n\n    ArraySized.random n5 (Random.float 0 1)\n\n    --: Random.Generator (ArraySized (In N5 (Add5 a_)) Float)\n    N.random\n\n","type":"N.N (N.In min max difference_) -> Random.Generator element -> Random.Generator (ArraySized.ArraySized (ArraySized.In min max) element)"},{"name":"repeat","comment":" An `ArraySized` with a given amount of same elements.\n\n    import N exposing (n4)\n\n    ArraySized.repeat n4 'L'\n        --: ArraySized (In N4 (Add4 a)) Char\n        |> ArraySized.toList\n    --> [ 'L', 'L', 'L', 'L' ]\n\n    ArraySized.repeat atLeast3 'L'\n    --: ArraySized (Min N3) Char\n\n","type":"N.N (N.In min max difference_) -> element -> ArraySized.ArraySized (ArraySized.In min max) element"},{"name":"reverse","comment":" Alias to `ArraySized.order Down`: flip the order of the elements.\n\n    ArraySized.l4 \"l\" \"i\" \"v\" \"e\"\n        |> ArraySized.reverse\n        --: ArraySized (In N4 (Add4 a_)) String\n        |> ArraySized.toList\n    --> [ \"e\", \"v\", \"i\", \"l\" ]\n\n","type":"ArraySized.ArraySized length element -> ArraySized.ArraySized length element"},{"name":"take","comment":" A certain number of elements from a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/).\n\n    import Linear exposing (DirectionLinear(..))\n    import N exposing (n7)\n\n    ArraySized.l8 0 1 2 3 4 5 6 7\n        |> ArraySized.take Up n7\n        --: ArraySized (In N7 (Add7 a_)) number_\n        |> ArraySized.toList\n    --> [ 0, 1, 2, 3, 4, 5, 6 ]\n\nUse [`takeAtMost`](#takeAtMost) if you don't know the exact amount of elements to take.\n\n","type":"Linear.DirectionLinear -> N.N (N.In taken atLeastTaken (N.Is (N.Diff minNotTaken_ N.To min) is_)) -> ArraySized.ArraySized (ArraySized.In min maxLength_) element -> ArraySized.ArraySized (ArraySized.In taken atLeastTaken) element"},{"name":"takeAtMost","comment":" A certain number of elements from a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/).\n\n    import Linear exposing (DirectionLinear(..))\n    import N exposing (n7)\n\n    ArraySized.l8 0 1 2 3 4 5 6 7\n        |> ArraySized.takeAtMost Up n7 between3And7\n    --: ArraySized (In N3 (Add7 a_)) ...\n\nThe first number is the maximum taken amount. The second number is the amount of taken elements.\n\nUse [`take`](ArraySized#take) if you know the exact amount of elements to take.\n\n","type":"Linear.DirectionLinear -> N.N (N.In maxTaken atLeastMaxTaken (N.Is (N.Diff minNotTaken_ N.To min) is_)) -> N.N (N.In minTaken maxTaken takenDifference_) -> ArraySized.ArraySized (ArraySized.In min maxLength_) element -> ArraySized.ArraySized (ArraySized.In minTaken atLeastMaxTaken) element"},{"name":"to1","comment":" Access 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`.\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.until n4\n        |> ArraySized.map N.toInt\n        |> ArraySized.toArray\n    --> Array.fromList [ 0, 1, 2, 3, 4 ]\n\n","type":"ArraySized.ArraySized length_ element -> Array.Array element"},{"name":"toChunksOf","comment":" Split the `ArraySized` into equal-sized (except `remainder`) slices\nin a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\n\n  - `groups`: the ArraySized divided into equal-sized Arrs\n  - `less`: values to one side that don't fill a whole group\n\n↓\n\n    import Linear exposing (DirectionLinear(..))\n    import N exposing (n0, n5)\n\n    ArraySized.l7 1 2 3 4 5 6 7\n        |> ArraySized.toChunksOf n5 { remainder = Up }\n        --: { chunks :\n        --:     ArraySized (In N0 (Add7 a_))\n        --:         (ArraySized (In N5 (Add5 b_)) number_)\n        --: remainder :\n        --:     ArraySized (In N0 (Add5 c_)) 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 n5 { remainder = Down }\n        |> .remainder\n        |> ArraySized.toList\n    --> [ 1, 2 ]\n\n","type":"N.N (N.In (N.Add1 chunkSizeMinMinus1) (N.Add1 chunkSizeMaxMinus1) chunkSizeDifference_) -> { remainder : Linear.DirectionLinear } -> ArraySized.ArraySized (ArraySized.In minLength_ max) element -> { chunks : ArraySized.ArraySized (ArraySized.In N.N0 max) (ArraySized.ArraySized (ArraySized.In (N.Add1 chunkSizeMinMinus1) (N.Add1 chunkSizeMaxMinus1)) element), remainder : ArraySized.ArraySized (ArraySized.In N.N0 chunkSizeMaxMinus1) 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 (ArraySized.In min_ N.N1) element -> Emptiable.Emptiable element Possibly.Possibly"},{"name":"toList","comment":" Convert to a `List`.\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.until n4\n        |> ArraySized.map N.toInt\n        |> ArraySized.toList\n    --> [ 0, 1, 2, 3, 4 ]\n\n","type":"ArraySized.ArraySized length_ element -> List.List element"},{"name":"until","comment":" Increasing natural numbers until including a given number.\n\n    import N exposing (n3)\n\n    ArraySized.until n3\n    --: ArraySized\n    --:     (In N4 (Add4 a))\n    --:     (N (N.In N0 (Add3 a)))\n        |> ArraySized.map N.toInt\n        |> ArraySized.toList\n    --> [ 0, 1, 2, 3 ]\n\n    ArraySized.until between2And9\n        |> ArraySized.map (N.add n3)\n    --: ArraySized\n    --:    (In N3 (Add10 a))\n    --:    (N (N.In N3 (Add12 a)))\n\n","type":"N.N (N.In min max difference_) -> ArraySized.ArraySized (ArraySized.In (N.Add1 min) (N.Add1 max)) (N.N (N.In N.N0 max {}))"}],"binops":[]}]