[{"name":"Arr","comment":" An `Arr` describes an array where you know more about the amount of elements.\n\n    Array.empty |> Array.get 0\n    --> Nothing\n\n    Arr.empty |> Arr.at nat0 FirstToLast\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 array =\n        array\n            |> Array.foldl\n                (\\a mayB ->\n                    case maybeC of\n                        Just b ->\n                            max a b\n\n                        Nothing ->\n                            a\n                )\n                Nothing\n\n    withArr : Arr (In (Nat1Plus minMinus1_) max_) comparable -> comparable\n    withArr =\n        Arr.foldWith FirstToLast max\n\nThe `Array` type doesn't give us the info that it contains 1+ elements. `Arr` simply knows more about the length at compile time, so you can e.g. call `foldWith` without a worry.\n\n@docs Arr\n\n\n# create\n\n@docs fromArray, fromList, fromMaybe, repeat, nats, minNats, random\n\n\n## exact\n\n@docs empty, from1\n\n[Skip to `from16`](Arr#from16).\n\n@docs from2, from3, from4, from5, from6, from7, from8, from9, from10, from11, from12, from13, from14, from15, from16\n\n\n# scan\n\n@docs length, at, all, any\n\n\n# modify\n\n@docs replaceAt, updateAt, resize, reverse, order\n\n\n## filter\n\n@docs when, dropWhen, whenJust, whenAllJust\n\n\n## part\n\n@docs take, takeMax, groupsOf\n\n\n# transform\n\n@docs map, fold, foldWith, toArray, toList, toMaybe\n\n\n## extract\n\n@docs to1\n@docs to2\n\n[Skip to `to14`](Arr#to14).\n\n@docs to3, to4, to5, to6, to7, to8, to9, to10, to11, to12, to13, to14\n\n\n## combine\n\n@docs map2, map3, map4\n\n\n## drop information\n\n@docs lowerMinLength, toMin\n\n\n## restore\n\n@docs restoreMaxLength\n\n\n# error\n\n@docs Error, Expectation, errorToString\n\n","unions":[{"name":"Expectation","comment":" An expectation for the decoded array that hasn't been met.\n\n  - `ExpectLength`: expected a different exact length\n  - `LengthInBound`: expected a length within a range (→ see [`InNat.Expectation`](https://package.elm-lang.org/packages/lue-bird/elm-bounded-nat/latest/InNat#Expectation))\n      - `ExpectAtLeast` some minimum in a range\n      - `ExpectAtMost` some maximum in a range\n\nSee [errorToString](Arr#errorToString) and the `serialize` functions.\n\n","args":[],"cases":[["ExpectLength",["Nat.Nat (Nat.Min Nats.Nat0)"]],["LengthInBound",["InNat.Expectation"]]]}],"aliases":[{"name":"Arr","comment":" An `Arr` describes an array where you know more about the amount of elements.\n\n\n## types\n\n  - amount >= 5\n\n```\nArr (Min Nat5) ...\n```\n\n  - 2 <= amount <= 12\n\n```\nArr (In Nat2 (Nat12Plus a_)) ...\n```\n\n\n### as argument types\n\n  - = 15\n\n```\nArr (Only Nat15) ...\n```\n\n  - amount >= 4\n\n```\nArr (In (Nat4Plus minMinus4_) max_) ...\n```\n\n  - 4 <= amount <= 15\n\n```\nArr (In (Nat4Plus minMinus4_) Nat15) ...\n```\n\n\n## as storage types\n\nTo store in your `Model` for example (which means: no type variables)\n\n  - = 15\n\n```\nArr (Only Nat15) ...\n```\n\n  - amount >= 4\n\n```\nArr (Min Nat4) ...\n```\n\n  - 4 <= amount <= 15\n\n```\nArr (In Nat4 Nat15) ...\n```\n\n","args":["length","element"],"type":"Typed.Typed Typed.Checked Internal.ArrTag Typed.Internal (Internal.Content length element)"},{"name":"Error","comment":" An error for when a decoded array doesn't have the expected length.\n\nYou can transform it into a message with [`errorToString`](Arr#errorToString).\n\nSee the `serialize` functions.\n\n","args":[],"type":"{ expected : Arr.Expectation, actual : { length : Nat.Nat (Nat.Min Nats.Nat0) } }"}],"values":[{"name":"all","comment":" Whether all elements satisfy a test.\n\n    Arr.all isEven (Arr.from2 2 4)\n    --> True\n\n    Arr.all isEven (Arr.from2 2 3)\n    --> False\n\n    Arr.all isEven Arr.empty\n    --> True\n\n","type":"(element -> Basics.Bool) -> Arr.Arr length_ element -> Basics.Bool"},{"name":"any","comment":" Whether any elements satisfy a test.\n\n    Arr.any isEven (Arr.from2 1 3)\n    --> True\n\n    Arr.any isEven (Arr.from2 1 2)\n    --> False\n\n    Arr.any isEven Arr.empty\n    --> False\n\n","type":"(element -> Basics.Bool) -> Arr.Arr length_ element -> Basics.Bool"},{"name":"at","comment":" The element at a valid position in a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/).\n\n    Arr.from4 0 1 2 3\n        |> Arr.at nat1 FirstToLast\n    --> 1\n\n    Arr.from4 0 1 2 3\n        |> Arr.at nat1 LastToFirst\n    --> 2\n\n","type":"Nat.Nat (Nat.ArgIn indexMin_ minLengthMinus1 indexIfN_) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In (Nats.Nat1Plus minLengthMinus1) maxLength_) element -> element"},{"name":"dropWhen","comment":" Remove values where a condition is met.\n\n    Arr.from5 1 2 3 4 5\n        |> Arr.dropWhen (\\n -> n < 3)\n    --> Arr.from3 3 4 5\n    --> : Arr (In Nat0 (Nat5Plus a_)) number_\n\n","type":"(element -> Basics.Bool) -> Arr.Arr (Nat.In minLength_ maxLength) element -> Arr.Arr (Nat.In Nats.Nat0 maxLength) element"},{"name":"empty","comment":" No elements.\n\n    Arr.empty\n    --> : Arr (In Nat0 atLeast0_) element\n        |> InArr.push \":)\"\n    --> : Arr (In Nat1 (Nat1Plus atLeast0_)) String\n\n","type":"Arr.Arr (Nat.In Nats.Nat0 atLeast0_) element_"},{"name":"errorToString","comment":" Convert an error to a readable message.\n\n    { expected = Arr.ExpectLength nat11\n    , actual = { length = nat10 }\n    }\n        |> Arr.errorToString\n    --> \"Expected an array of length 11, but the actual length was 10.\"\n\n(example doesn't compile)\n\n","type":"Arr.Error -> String.String"},{"name":"fold","comment":" Reduce an `Arr` in a [direction](https://package.elm-lang.org/packages/indique/elm-linear-direction/latest/).\n\n    Arr.from5 \"l\" \"i\" \"v\" \"e\"\n        |> Arr.fold FirstToLast (++) \"\"\n    --> \"live\"\n\n    Arr.from5 \"l\" \"i\" \"v\" \"e\"\n        |> Arr.fold LastToFirst (++) \"\"\n    --> \"evil\"\n\n    sum =\n        Arr.fold FirstToLast (+) 0\n\n    product =\n        Arr.fold FirstToLast (*) 0\n\n","type":"LinearDirection.LinearDirection -> (element -> result -> result) -> result -> Arr.Arr length_ element -> result"},{"name":"foldWith","comment":" A fold in a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/) where the initial result is the first value in the `Arr`.\n\n    Arr.foldWith FirstToLast maximum\n        (Arr.from3 234 345 543)\n    --> 543\n\n    Arr.foldWith LastToFirst (++)\n        (Arr.from3 \"m\" \"l\" \"e\")\n    --> \"elm\"\n\n","type":"LinearDirection.LinearDirection -> (element -> element -> element) -> Arr.Arr (Nat.In (Nats.Nat1Plus minLengthMinus1_) maxLength_) element -> element"},{"name":"from1","comment":" Create an `Arr` with exactly 1 element.\n","type":"element -> Arr.Arr (Nat.In Nats.Nat1 (Nats.Nat1Plus a_)) element"},{"name":"from10","comment":" Create an `Arr` with exactly 10 elements in this order.\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> Arr.Arr (Nat.In Nats.Nat10 (Nats.Nat10Plus a_)) element"},{"name":"from11","comment":" Create an `Arr` with exactly 11 elements in this order.\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> Arr.Arr (Nat.In Nats.Nat11 (Nats.Nat11Plus a_)) element"},{"name":"from12","comment":" Create an `Arr` with exactly 12 elements in this order.\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> Arr.Arr (Nat.In Nats.Nat12 (Nats.Nat12Plus a_)) element"},{"name":"from13","comment":" Create an `Arr` with exactly 13 elements in this order.\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> Arr.Arr (Nat.In Nats.Nat13 (Nats.Nat13Plus a_)) element"},{"name":"from14","comment":" Create an `Arr` with exactly 14 elements in this order.\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> Arr.Arr (Nat.In Nats.Nat14 (Nats.Nat14Plus a_)) element"},{"name":"from15","comment":" Create an `Arr` with exactly 15 elements in this order.\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> Arr.Arr (Nat.In Nats.Nat15 (Nats.Nat15Plus a_)) element"},{"name":"from16","comment":" Create an `Arr` 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 -> Arr.Arr (Nat.In Nats.Nat16 (Nats.Nat16Plus a_)) element"},{"name":"from2","comment":" Create an `Arr` with exactly 2 elements in this order.\n","type":"element -> element -> Arr.Arr (Nat.In Nats.Nat2 (Nats.Nat2Plus a_)) element"},{"name":"from3","comment":" Create an `Arr` with exactly 3 elements in this order.\n","type":"element -> element -> element -> Arr.Arr (Nat.In Nats.Nat3 (Nats.Nat3Plus a_)) element"},{"name":"from4","comment":" Create an `Arr` with exactly 4 elements in this order.\n","type":"element -> element -> element -> element -> Arr.Arr (Nat.In Nats.Nat4 (Nats.Nat4Plus a_)) element"},{"name":"from5","comment":" Create an `Arr` with exactly 5 elements in this order.\n","type":"element -> element -> element -> element -> element -> Arr.Arr (Nat.In Nats.Nat5 (Nats.Nat5Plus a_)) element"},{"name":"from6","comment":" Create an `Arr` with exactly 6 elements in this order.\n","type":"element -> element -> element -> element -> element -> element -> Arr.Arr (Nat.In Nats.Nat6 (Nats.Nat6Plus a_)) element"},{"name":"from7","comment":" Create an `Arr` with exactly 7 elements in this order.\n","type":"element -> element -> element -> element -> element -> element -> element -> Arr.Arr (Nat.In Nats.Nat7 (Nats.Nat7Plus a_)) element"},{"name":"from8","comment":" Create an `Arr` with exactly 8 elements in this order.\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> Arr.Arr (Nat.In Nats.Nat8 (Nats.Nat8Plus a_)) element"},{"name":"from9","comment":" Create an `Arr` with exactly 9 elements in this order.\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> Arr.Arr (Nat.In Nats.Nat9 (Nats.Nat9Plus a_)) element"},{"name":"fromArray","comment":" Create an `Arr` from an `Array`.\n\nAs every `Array` has `>= 0` elements:\n\n    Arr.fromArray arrayFromSomewhere\n    --> : Arr (Min Nat0)\n\nDon't use it this way:\n\n    Arr.fromArray\n        (Array.fromList [ 0, 1, 2, 3, 4, 5, 6 ])\n    --> big no\n\nTell the compiler if you know the amount of elements. Make sure the it knows as much as you!\n\n    Arr.from7 0 1 2 3 4 5 6\n    --> ok\n\n    Arr.nats nat7\n    --> big yes\n\n","type":"Array.Array element -> Arr.Arr (Nat.Min Nats.Nat0) element"},{"name":"fromList","comment":" Short for `Array.fromList list |> Arr.fromArray`. Create an `Arr` from a `List`.\n\nAs every `List` has `>= 0` elements:\n\n    Arr.fromList listFromSomewhere\n    --> : Arr (Min Nat0)\n\nDon't use it this way:\n\n    Arr.fromList [ 0, 1, 2, 3, 4, 5, 6 ]\n    --> big no!\n\nTell the compiler if you know the amount of elements. Make sure the it knows as much as you!\n\n    Arr.from7 0 1 2 3 4 5 6\n    --> ok\n\n    Arr.nats nat7\n    --> big yes\n\n","type":"List.List element -> Arr.Arr (Nat.Min Nats.Nat0) element"},{"name":"fromMaybe","comment":" `Arr.from1` if `Just`, `empty` if `Nothing`.\n\n    Arr.fromMaybe (Just \"hi\")\n    --> Arr.from1 \"hi\"\n    --> : Arr (In Nat0 (Nat1Plus a_))\n\n    Arr.fromMaybe Nothing\n    --> Arr.empty\n    --> : Arr (In Nat0 (Nat1Plus a_))\n\n","type":"Maybe.Maybe element -> Arr.Arr (Nat.In Nats.Nat0 (Nats.Nat1Plus a_)) element"},{"name":"groupsOf","comment":" Split the `Arr` into equal-sized chunks in a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/).\n\n  - `groups`: the Arr divided into equal-sized Arrs\n  - `less`: values to one side that don't fill a whole group\n\n```\nArr.from7 1 2 3 4 5 6 7\n    |> Arr.groupsOf nat5 FirstToLast\n--> { groups =\n-->     Arr.from1 (Arr.from5 1 2 3 4 5)\n-->     : Arr (In Nat0 (Nat7Plus a_))\n-->         (Arr (In Nat5 (Nat5Plus b_)) number_)\n--> , remaining =\n-->     Arr.from2 6 7\n-->     : Arr (In Nat0 (Nat5Plus c_)) number_\n--> }\n\nArr.from7 1 2 3 4 5 6 7\n    |> Arr.groupsOf nat5 LastToFirst\n--> { groups = Arr.from1 (Arr.from5 3 4 5 6 7) : ...\n--> , remaining = Arr.from2 1 2 : ...\n--> }\n```\n\n","type":"Nat.Nat (Nat.ArgIn (Nats.Nat1Plus minGroupSizeMinus1) maxGroupSize groupSizeIfN_) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In minLength_ maxLength) element -> { groups : Arr.Arr (Nat.In Nats.Nat0 maxLength) (Arr.Arr (Nat.In (Nats.Nat1Plus minGroupSizeMinus1) maxGroupSize) element), remaining : Arr.Arr (Nat.In Nats.Nat0 maxGroupSize) element }"},{"name":"length","comment":" The amount of elements.\n\n    Arr.from3 1 2 3 |> Arr.length\n    --> nat3 : Nat (In Nat3 (Nat3Plus a_))\n\n    between3And5Elements |> Arr.length\n    --> : Nat (In Nat3 (Nat5Plus a_))\n\n    atLeast3Elements |> Arr.length\n    --> : Nat (Min Nat3)\n\n","type":"Arr.Arr length element_ -> Nat.Nat length"},{"name":"lowerMinLength","comment":" Use a lower minimum length in the type.\n\n    [ atLeast3Elements\n    , atLeast4Elements\n    ]\n\nElm complains:\n\n> But all the previous elements in the list are\n> `Arr (Min Nat3) ...`\n\n    [ atLeast3Elements\n    , atLeast4Elements\n        |> Arr.lowerMinLength nat3\n    ]\n\n","type":"Nat.Nat (Nat.ArgIn newMinLength minLength newMinIfN_) -> Arr.Arr (Nat.In minLength maxLength) element -> Arr.Arr (Nat.In newMinLength maxLength) element"},{"name":"map","comment":" Change every element.\n\n    aToZ : Arr (In Nat26 (Nat26Plus a_)) Char\n    aToZ =\n        Arr.nats nat26\n            |> Arr.map (val >> inABC)\n\n    inABC index =\n        ('a' |> Char.toCode)\n            + index\n            |> Char.fromCode\n\n`val` refers to [`Typed.val`](https://package.elm-lang.org/packages/lue-bird/elm-typed-value/latest/Typed#val).\n\n","type":"(element -> mappedElement) -> Arr.Arr length element -> Arr.Arr length mappedElement"},{"name":"map2","comment":" Combine the elements of 2 `Arr`s into new elements.\nIf one list is longer, its extra elements are not used.\n\n    teamLives aBoard bBoard =\n        Arr.map2 (\\a b -> a.lives + b.lives)\n            aBoard\n            bBoard\n\nThe length of all `Arr`s must be in the same range.\n\n  - If 1 `Arr`'s maximum length isn't known:\n\n```\nArr.map2 (\\a b -> a.lives + b.lives)\n    (aBoard |> Arr.toMin)\n    (bBoard |> Arr.toMin)\n\naBoard : Arr (In Nat2 someMax_) Field\nbBoard : Arr (In Nat2 otherMax_) Field\n```\n\n  - If 1 `Arr` has a higher minimum length:\n\n```\nArr.map2 (\\a b -> a.lives + b.lives)\n    (aBoard |> Arr.lowerMinLength nat2)\n    bBoard\n\naBoard : Arr (In Nat5 Nat10) Field\n```\n\n","type":"(a -> b -> combinedElement) -> Arr.Arr length a -> Arr.Arr length b -> Arr.Arr length combinedElement"},{"name":"map3","comment":" Combine the elements of 3 `Arr`s into new elements. Works like [map2](Arr#map2).\n","type":"(a -> b -> c -> combinedElement) -> Arr.Arr length a -> Arr.Arr length b -> Arr.Arr length c -> Arr.Arr length combinedElement"},{"name":"map4","comment":" Combine the elements of 4 `Arr`s into new elements. Works like [map2](Arr#map2).\n","type":"(a -> b -> c -> d -> combinedElement) -> Arr.Arr length a -> Arr.Arr length b -> Arr.Arr length c -> Arr.Arr length d -> Arr.Arr length combinedElement"},{"name":"minNats","comment":" Increasing natural numbers until below a given value.\n\nUse [nats](Arr#nats) if you know the maximum length:\n\n    Arr.nats nat5\n\n    Arr.nats between2And10\n\nIf you don't:\n\n    Arr.minNats atLeast10\n    --> : Arr (Min Nat10)\n    -->     (Nat (Min Nat10))\n\n    from first length =\n        Arr.minNats length\n            |> Arr.map (MinNat.add first)\n\n","type":"Nat.Nat (Nat.ArgIn min max ifN_) -> Arr.Arr (Nat.In min max) (Nat.Nat (Nat.In Nats.Nat0 max))"},{"name":"nats","comment":" Increasing natural numbers until below a given value.\n\n    Arr.nats nat4\n    --> Arr.from4 (Nat 0) (Nat 1) (Nat 2) (Nat 3)\n    --> : Arr\n    -->     (In Nat4 (Nat4PLus a))\n    -->     (Nat (In Nat0 (Nat3Plus a)))\n\n    Arr.nats between2And10\n    --> : Arr\n    -->     (In Nat2 (Nat10Plus a))\n    -->     (Nat (In Nat0 (Nat9Plus a)))\n\n    from first length =\n        Arr.nats length\n            |> Arr.map (InNat.add first)\n\nIf you want to use a `Nat` as the length, but you don't know the maximum, e.g.\n\n    Arr.nats (Nat.intAtLeast nat5 someInt) -- error\n\nuse [minNats](Arr#minNats).\n\n","type":"Nat.Nat (Nat.ArgIn min (Nats.Nat1Plus maxMinus1) ifN_) -> Arr.Arr (Nat.In min (Nats.Nat1Plus maxMinus1)) (Nat.Nat (Nat.In Nats.Nat0 maxMinus1))"},{"name":"order","comment":" Keep the order if [`FirstToLast`](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/LinearDirection#LinearDirection),\nreverse if [`LastToFirst`](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/LinearDirection#LinearDirection).\n\n    Arr.from3 1 2 3\n        |> Arr.order LastToFirst\n    --> Arr.from3 3 2 1\n\n    Arr.from3 1 2 3\n        |> Arr.order FirstToLast\n    --> Arr.from3 1 2 3\n\n","type":"LinearDirection.LinearDirection -> Arr.Arr length element -> Arr.Arr length element"},{"name":"random","comment":" Generate a given amount of elements and put them in an `Arr`.\n\n    Arr.random nat5 (Random.float 0 1)\n\n    --> : Random.Generator (Arr (In Nat5 (Nat5Plus a_)) Float)\n    Nat.random\n\n","type":"Nat.Nat (Nat.ArgIn minLength maxLength ifN_) -> Random.Generator element -> Random.Generator (Arr.Arr (Nat.In minLength maxLength) element)"},{"name":"repeat","comment":" An `Arr` with a given amount of same elements.\n\n    Arr.repeat nat4 'L'\n    --> Arr.from4 'L' 'L' 'L' 'L'\n\n    Arr.repeat atLeast3 'L'\n    --> : Arr (Min Nat3) Char\n\n","type":"Nat.Nat (Nat.ArgIn min max ifN_) -> element -> Arr.Arr (Nat.In min max) element"},{"name":"replaceAt","comment":" Set the element at an index in a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/).\n\n    Arr.from3 \"I\" \"am\" \"ok\"\n        |> Arr.replaceAt nat2 FirstToLast \"confusion\"\n    --> Arr.from3 \"I\" \"am\" \"confusion\"\n\n    Arr.from3 \"I\" \"am\" \"ok\"\n        |> Arr.replaceAt nat1 LastToFirst \"feel\"\n    --> Arr.from3 \"I\" \"feel\" \"ok\"\n\nAn index that's out of bounds is ignored.\n\n    Arr.from3 \"I\" \"am\" \"ok\"\n        |> Arr.replaceAt nat3 LastToFirst \"feel\"\n    --> Arr.from3 \"I\" \"am\" \"ok\"\n\n","type":"Nat.Nat index_ -> LinearDirection.LinearDirection -> element -> Arr.Arr length element -> Arr.Arr length element"},{"name":"resize","comment":" Resize an `Arr` in a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/), padding with a given value.\n\n    Arr.resize LastToFirst nat4 0\n        (Arr.from2 1 2)\n    --> Arr.from4 0 0 1 2\n\n    Arr.resize LastToFirst nat2 0\n        (Array.from3 1 2 3)\n    --> Arr.from2 2 3\n\n    Arr.resize FirstToLast nat4 0\n        (Array.from2 1 2)\n    --> Arr.from4 1 2 0 0\n\n    Arr.resize FirstToLast nat2 0\n        (Array.from3 1 2 3)\n    --> Arr.from2 1 2\n\nThis is a quick way to gain some type-level knowledge about the length.\n\n","type":"LinearDirection.LinearDirection -> Nat.Nat (Nat.ArgIn newMinLength newMaxLength ifN_) -> element -> Arr.Arr length_ element -> Arr.Arr (Nat.In newMinLength newMaxLength) element"},{"name":"restoreMaxLength","comment":" Make an `Arr` with a fixed maximum length fit into functions with require a higher maximum length.\n\nWhile designing argument annotations as general as possible:\n\n    atMost18Elements : Arr (In min_ Nat18) ...\n\nThe argument in `atMost18Elements` should also fit in `atMost19Elements`.\n\n    atMost19Elements theArgument\n    --> error :(\n\n    atMost19Elements\n        (theArgument |> Arr.restoreMaxLength nat18)\n    --> works\n\n","type":"Nat.Nat (Nat.ArgIn max newMax ifN_) -> Arr.Arr (Nat.In min max) element -> Arr.Arr (Nat.In min newMax) element"},{"name":"reverse","comment":" Alias to `Arr.order LastToFirst`: flip the order of the elements.\n\n    Arr.from4 \"l\" \"i\" \"v\" \"e\"\n        |> Arr.reverse\n    --> Arr.from4 \"e\" \"v\" \"i\" \"l\"\n\n","type":"Arr.Arr length element -> Arr.Arr 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    Arr.from8 0 1 2 3 4 5 6 7\n        |> Arr.take nat7 FirstToLast\n    --> Arr.from7 0 1 2 3 4 5 6\n\nUse [`takeMax`](Arr#takeMax) if you don't know the exact amount of elements to take.\n\n","type":"Nat.Nat (Nat.N taken atLeastTaken (Nat.Is minNotTaken_ Nat.To minLength) is_) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In minLength maxLength_) element -> Arr.Arr (Nat.In taken atLeastTaken) element"},{"name":"takeMax","comment":" A certain number of elements from a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/).\n\n    Arr.from8 0 1 2 3 4 5 6 7\n        |> Arr.takeMax nat7 between3And7 FirstToLast\n    --> : Arr (In Nat3 (Nat7Plus a_)) ...\n\nThe first number is the maximum taken amount. The second number is the amount of taken elements.\n\nUse [`take`](Arr#take) if you know the exact amount of elements to take.\n\n","type":"Nat.Nat (Nat.N maxTaken atLeastMaxTaken (Nat.Is minNotTaken_ Nat.To minLength) is_) -> Nat.Nat (Nat.ArgIn minTaken maxTaken takenIfN_) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In minLength maxLength_) element -> Arr.Arr (Nat.In minTaken atLeastMaxTaken) element"},{"name":"to1","comment":" Access the only value in the `Arr`.\n\n    Arr.to1 (Arr.from1 \"hi\")\n    --> \"hi\"\n\n","type":"Arr.Arr (Nat.Only Nats.Nat1) element -> element"},{"name":"to10","comment":" Transform the `Arr` into a `Toop.T10`. This makes accessing elements and pattern matching easier.\n","type":"Arr.Arr (Nat.Only Nats.Nat10) element -> Toop.T10 element element element element element element element element element element"},{"name":"to11","comment":" Transform the `Arr` into a `Toop.T11`. This makes accessing elements and pattern matching easier.\n","type":"Arr.Arr (Nat.Only Nats.Nat11) element -> Toop.T11 element element element element element element element element element element element"},{"name":"to12","comment":" Transform the `Arr` into a `Toop.T12`. This makes accessing elements and pattern matching easier.\n","type":"Arr.Arr (Nat.Only Nats.Nat12) element -> Toop.T12 element element element element element element element element element element element element"},{"name":"to13","comment":" Transform the `Arr` into a `Toop.T13`. This makes accessing elements and pattern matching easier.\n","type":"Arr.Arr (Nat.Only Nats.Nat13) element -> Toop.T13 element element element element element element element element element element element element element"},{"name":"to14","comment":" Transform the `Arr` into a `Toop.T14`. This makes accessing elements and pattern matching easier.\n","type":"Arr.Arr (Nat.Only Nats.Nat14) element -> Toop.T14 element element element element element element element element element element element element element element"},{"name":"to2","comment":" Transform the `Arr` into a `Toop.T2`. This makes accessing elements and pattern matching easier.\n","type":"Arr.Arr (Nat.Only Nats.Nat2) element -> Toop.T2 element element"},{"name":"to3","comment":" Transform the `Arr` into a `Toop.T3`. This makes accessing elements and pattern matching easier.\n","type":"Arr.Arr (Nat.Only Nats.Nat3) element -> Toop.T3 element element element"},{"name":"to4","comment":" Transform the `Arr` into a `Toop.T4`. This makes accessing elements and pattern matching easier.\n","type":"Arr.Arr (Nat.Only Nats.Nat4) element -> Toop.T4 element element element element"},{"name":"to5","comment":" Transform the `Arr` into a `Toop.T5`. This makes accessing elements and pattern matching easier.\n","type":"Arr.Arr (Nat.Only Nats.Nat5) element -> Toop.T5 element element element element element"},{"name":"to6","comment":" Transform the `Arr` into a `Toop.T6`. This makes accessing elements and pattern matching easier.\n","type":"Arr.Arr (Nat.Only Nats.Nat6) element -> Toop.T6 element element element element element element"},{"name":"to7","comment":" Transform the `Arr` into a `Toop.T7`. This makes accessing elements and pattern matching easier.\n","type":"Arr.Arr (Nat.Only Nats.Nat7) element -> Toop.T7 element element element element element element element"},{"name":"to8","comment":" Transform the `Arr` into a `Toop.T8`. This makes accessing elements and pattern matching easier.\n","type":"Arr.Arr (Nat.Only Nats.Nat8) element -> Toop.T8 element element element element element element element element"},{"name":"to9","comment":" Transform the `Arr` into a `Toop.T9`. This makes accessing elements and pattern matching easier.\n","type":"Arr.Arr (Nat.Only Nats.Nat9) element -> Toop.T9 element element element element element element element element element"},{"name":"toArray","comment":" Convert the `Arr` to an `Array`.\nJust do this in the end.\nTry to keep extra information as long as you can.\n\n    Arr.nats nat5\n        |> Arr.map val\n        |> Arr.toArray\n    --> Array.fromList [ 0, 1, 2, 3, 4 ]\n\n`val` refers to [`Typed.val`](https://package.elm-lang.org/packages/lue-bird/elm-typed-value/latest/Typed#val).\n\n","type":"Arr.Arr length_ element -> Array.Array element"},{"name":"toList","comment":" Short for `Arr.toArray arr |> Array.toList`. Convert the `Arr` to a `List`.\nJust do this in the end.\nTry to keep extra information as long as you can.\n\n    Arr.nats nat5\n        |> Arr.map val\n        |> Arr.toList\n    --> [ 0, 1, 2, 3, 4 ]\n\n`val` refers to [`Typed.val`](https://package.elm-lang.org/packages/lue-bird/elm-typed-value/latest/Typed#val).\n\n","type":"Arr.Arr length_ element -> List.List element"},{"name":"toMaybe","comment":" `Nothing` if the `Arr` is `empty`, else `Just` it's only value.\n","type":"Arr.Arr (Nat.In min_ Nats.Nat1) element -> Maybe.Maybe element"},{"name":"toMin","comment":" Convert the `Arr (In min ...)` to a `Arr (Min min)`.\n\n    between4And10Elements |> Arr.toMin\n    --> : Arr (Min Nat4) ...\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> `Arr (Min Nat1) ...`\n\n    [ atLeast1Element\n    , between1And10Elements |> Arr.toMin\n    ]\n\n","type":"Arr.Arr (Nat.In min max_) element -> Arr.Arr (Nat.Min min) element"},{"name":"updateAt","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    Arr.from3 1 20 30\n        |> Arr.updateAt nat0 FirstToLast ((*) 10)\n    --> Arr.from3 10 20 30\n\n    Arr.from3 1 20 30\n        |> Arr.updateAt nat0 LastToFirst (\\x -> -x)\n    --> Arr.from3 1 20 -30\n\nAn index that's out of bounds is ignored.\n\n    Arr.from3 1 20 30\n        |> Arr.updateAt nat3 FirstToLast ((*) 10)\n    --> Arr.from3 1 20 30\n\n","type":"Nat.Nat index_ -> LinearDirection.LinearDirection -> (element -> element) -> Arr.Arr length element -> Arr.Arr length element"},{"name":"when","comment":" Only keep values that satisfy a test.\n\n    Arr.from5 1 2 3 4 5\n        |> Arr.when (\\n -> n >= 3)\n    --> Arr.from3 3 4 5\n    --> : Arr (In Nat0 (Nat5Plus a_)) number_\n\n","type":"(element -> Basics.Bool) -> Arr.Arr (Nat.In minLength_ maxLength) element -> Arr.Arr (Nat.In Nats.Nat0 maxLength) element"},{"name":"whenAllJust","comment":" If every `Maybe` is present, return all of the values. Return `Nothing` if any element is `Nothing`.\n\n    Arr.empty |> Arr.whenAllJust\n    --> Just Arr.empty\n\n    Arr.from3 (Just 1) (Just 2) (Just 3)\n        |> Arr.whenAllJust\n    --> Just (Arr.from3 1 2 3)\n\n    Arr.from3 (Just 1) Nothing (Just 3)\n        |> Arr.whenAllJust\n    --> Nothing\n\nFunnily, this can sometimes even be nicer than `Maybe.mapN`:\n\n    groupCall =\n        Arr.from5 aUser bUser cUser dUser eUser\n            |> Arr.map .phoneNumber\n            |> Arr.whenAllJust\n\n    -- vs\n    groupCall =\n        Maybe.map5 Toop.T5\n            aUser.phoneNumber\n            bUser.phoneNumber\n            cUser.phoneNumber\n            dUser.phoneNumber\n            eUser.phoneNumber\n\n","type":"Arr.Arr length (Maybe.Maybe value) -> Maybe.Maybe (Arr.Arr length value)"},{"name":"whenJust","comment":" Take every `Just value` & drop every `Nothing`.\n\n    Arr.from3 (Just \"This\") Nothing (Just \"fine\")\n        |> Arr.whenJust\n    --> Arr.from2 \"This\" \"fine\"\n    --> : Arr (In Nat0 (Nat3Plus a_)) String\n\n[Call `map` and then `whenJust` to get the same functionality as \"filterMap\"](https://github.com/lue-bird/elm-typesafe-array/blob/master/Q%20%26%20A.md#why-no-filtermap-but-only-whenjust).\n\n    Arr.from3 \"1.2\" \"2\" \"hello\"\n        |> Arr.map String.toInt\n        |> Arr.whenJust\n    --> Arr.from1 2\n    --> : Arr (In Nat0 (Nat3Plus a_)) Int\n\n","type":"Arr.Arr (Nat.In minLength_ maxLength) (Maybe.Maybe value) -> Arr.Arr (Nat.In Nats.Nat0 maxLength) value"}],"binops":[]},{"name":"InArr","comment":" If the length is `Only` or the maximum length is set to a specific value:\n\n    -- only up to 50 tags\n    tag : Arr (In min_ Nat50) String -> a -> Tagged a\n\nuse these operations instead of the ones in [`Arr`](Arr) or [`MinArr`](MinArr).\n\n\n# modify\n\n@docs push, removeAt, insertAt\n@docs intersperse\n\n\n## glue\n\n@docs append, appendIn, prepend, prependIn\n\n\n## part\n\n@docs drop\n\n\n# scan length\n\n@docs isLengthInRange, isLength, isLengthAtLeast, isLengthAtMost\n\n\n# transform\n\n\n## serialize\n\n@docs serialize, serializeIn\n\n\n## error\n\n@docs Error, generalizeError, errorToString\n\n","unions":[],"aliases":[{"name":"Error","comment":" An error for when the length of a decoded array is different from an exact expected length. You can transform it into\n\n  - a message: [`errorToString`](InArr#errorToString)\n  - an [`Arr.Error`](Arr#Error): [`generalizeError`](InArr#generalizeError)\n\nSee [`serialize`](InArr#serialize).\n\n","args":[],"type":"{ expected : { length : Nat.Nat (Nat.Min Nats.Nat0) }, actual : { length : Nat.Nat (Nat.Min Nats.Nat0) } }"}],"values":[{"name":"append","comment":" Attach elements of an `Arr` with an exact amount of elements to the right.\n\n    Arr.from3 1 2 3\n        |> InArr.append nat3 (Arr.from3 4 5 6)\n    --> Arr.from6 1 2 3 4 5 6\n\n","type":"Nat.Nat (Nat.N added atLeastAdded_ (Nat.Is minLength Nat.To minLengthSum) (Nat.Is maxLength Nat.To minSumMax)) -> Arr.Arr (Nat.Only added) element -> Arr.Arr (Nat.In minLength maxLength) element -> Arr.Arr (Nat.In minLengthSum minSumMax) element"},{"name":"appendIn","comment":" Attach elements of an `Arr` which has multiple possible amounts to the right.\n\n    Arr.from3 1 2 3\n        |> InArr.appendIn nat3 nat5\n            between3And5Elements\n    --> : Arr (In Nat6 (Nat8Plus a))\n\nUse [`append`](InArr#append) if the appended `Arr` has an exact amount of elements.\n\n","type":"Nat.Nat (Nat.N addedMin atLeastAddedMin_ (Nat.Is minLength Nat.To minLengthSum) addedMinIs_) -> Nat.Nat (Nat.N addedMax atLeastAddedMax_ (Nat.Is maxLength Nat.To maxLengthSum) addedMaxIs_) -> Arr.Arr (Nat.In addedMin addedMax) element -> Arr.Arr (Nat.In minLength maxLength) element -> Arr.Arr (Nat.In minLengthSum maxLengthSum) element"},{"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    Arr.from4 0 1 2 3\n        |> InArr.drop nat2 LastToFirst\n    --> Arr.from2 0 1\n\n    between6And10Elements\n        |> InArr.drop nat2 FirstToLast\n    --> : Arr (In Nat4 (Nat10Plus a_)) ...\n\n","type":"Nat.Nat (Nat.N dropped_ atLeastDropped_ (Nat.Is minTaken Nat.To minLength) (Nat.Is maxTaken Nat.To maxLength)) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In minLength maxLength) element -> Arr.Arr (Nat.In minTaken maxTaken) element"},{"name":"errorToString","comment":" Convert an error into a readable message.\n\n    { expected = { length = InNat.ExpectAtLeast nat11 }\n    , actual = { length = nat10 }\n    }\n        |> MinArr.errorToString\n    --> \"Expected an array of length >= 11, but the actual length was 10.\"\n\n(example doesn't compile)\n\nEquivalent to\n\n    error\n        |> InArr.generalizeError\n        |> Arr.errorToString\n\n","type":"InArr.Error -> String.String"},{"name":"generalizeError","comment":" Convert its error to a [`Arr.Error`](Arr#Error): an error type that covers all cases where `Array` to `Arr` conversions can fail.\n\n    import Serialize exposing (Codec)\n\n    Serialize.mapError MinArr.generalizeError\n    --> : Codec MinArr.Error a -> Codec Arr.Error a\n\nUse this if you serialize `Arr (In X (XPlus a_))` together with `Arr (In A Z)`:\n\n    Serialize.tuple\n        (InArr.serialize nat10 ...)\n        (InArr.serializeIn nat10 nat99 ...)\n    --> error : `Codec`s have different custom errors\n\n    Serialize.tuple\n        (InArr.serialize nat10\n            InArr.generalizeError ...\n        )\n        (InArr.serializeIn nat10 nat20\n            identity ...\n        )\n    --> Codec\n    -->     Arr.Error\n    -->     ( Arr (In Nat10 (Nat10Plus a_)) ...\n    -->     , Arr (In Nat10 (Nat20Plus b_)) ...\n    -->     )\n\nNote: There's also [`errorToString`](MinArr#errorToString).\n\n","type":"InArr.Error -> Arr.Error"},{"name":"insertAt","comment":" Put an element in the `Arr` at a given index in a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/).\n\n    Arr.from3 'a' 'c' 'd'\n        |> InArr.insertAt nat1 FirstToLast 'b'\n    --> Arr.from4 'a' 'b' 'c' 'd'\n\n    Arr.from3 'a' 'c' 'd'\n        |> Array.insertAt nat2 LastToFirst 'b'\n    --> Array.from4 'a' 'b' 'c' 'd'\n\n","type":"Nat.Nat (Nat.ArgIn indexMin_ minLength indexIfN_) -> LinearDirection.LinearDirection -> element -> Arr.Arr (Nat.In minLength maxLength) element -> Arr.Arr (Nat.In (Nats.Nat1Plus minLength) (Nats.Nat1Plus maxLength)) element"},{"name":"intersperse","comment":" Place a value between all members.\n\nTo get the correct final length type, we need to give the current minimum and maximum length as an arguments.\n\n    Arr.from3 \"turtles\" \"turtles\" \"turtles\"\n        |> InArr.intersperse \"on\" nat3 nat3\n    --> Arr.from5 \"turtles\" \"on\" \"turtles\" \"on\" \"turtles\"\n\n","type":"element -> Nat.Nat (Nat.N minLength atLeastMinLength_ (Nat.Is minLength Nat.To (Nats.Nat1Plus minDoubleLengthMinus1)) minIs_) -> Nat.Nat (Nat.N maxLength atLeastMaxLength_ (Nat.Is maxLength Nat.To (Nats.Nat1Plus maxDoubleLengthMinus1)) maxIs_) -> Arr.Arr (Nat.In minLength maxLength) element -> Arr.Arr (Nat.In minDoubleLengthMinus1 maxDoubleLengthMinus1) element"},{"name":"isLength","comment":" Compare its length to a given exact length. Is it `LessOrEqualOrGreater`?\n\n`lowest` can be a number <= the minimum length.\n\n    chooseFormation :\n        Arr (In min Nat50) Character\n        -> Formation\n    chooseFormation characters =\n        case\n            characters\n                |> InArr.isLength nat7 { lowest = nat0 }\n        of\n            Nat.Equal only7 ->\n                SpecialAttack only7\n\n            Nat.Less atMost6 ->\n                Retreat atMost6\n\n            Nat.Greater atLeast8 ->\n                Fight atLeast8\n\n","type":"Nat.Nat (Nat.N (Nats.Nat1Plus nMinus1) atLeastN (Nat.Is a_ Nat.To (Nats.Nat1Plus nPlusAMinus1)) (Nat.Is valueToMax_ Nat.To maxLength)) -> { lowest : Nat.Nat (Nat.N lowest atLeastLowest_ (Nat.Is lowestToMin_ Nat.To minLength) (Nat.Is minToValue_ Nat.To (Nats.Nat1Plus nMinus1))) } -> Arr.Arr (Nat.In minLength maxLength) element -> Nat.LessOrEqualOrGreater (Arr.Arr (Nat.In lowest nPlusAMinus1) element) (Arr.Arr (Nat.In (Nats.Nat1Plus nMinus1) atLeastN) element) (Arr.Arr (Nat.In (Nats.Nat2Plus nMinus1) maxLength) element)"},{"name":"isLengthAtLeast","comment":" Is its length `BelowOrAtLeast` as big as a `Nat`?\n\n`lowest` can be a number <= the minimum length.\n\n    first5 :\n        Arr (In minLength_ maxLength) element\n        -> Maybe (Arr (In Nat5 maxLength) element)\n    first5 arr =\n        case arr |> MinArr.isLengthAtLeast nat5 { lowest = nat0 } of\n            Nat.Below _ ->\n                Nothing\n\n            Nat.EqualOrGreater atLeast5 ->\n                Just atLeast5\n\n","type":"Nat.Nat (Nat.N lowerBound (Nats.Nat1Plus atLeastLowerBoundMinus1) (Nat.Is atLeastRange_ Nat.To maxLength) is_) -> { lowest : Nat.Nat (Nat.N lowest atLeastLowest_ (Nat.Is lowestToMin_ Nat.To minLength) (Nat.Is (Nats.Nat1Plus lowestToLowerBound_) Nat.To lowerBound)) } -> Arr.Arr (Nat.In minLength maxLength) element -> Nat.BelowOrAtLeast (Arr.Arr (Nat.In lowest atLeastLowerBoundMinus1) element) (Arr.Arr (Nat.In lowerBound maxLength) element)"},{"name":"isLengthAtMost","comment":" Is its length `AtMostOrAbove` a given length?\n\n`lowest` can be a number <= the minimum length.\n\n    -- at least 3 and only up to 50 tags\n    tag :\n        Arr (In (Nat3Plus orHigherMin_) Nat50) String\n        -> a\n        -> Tagged a\n\n    tagIfValidTags :\n        Arr (In (Nat3Plus orHigherMin_) max)\n        -> a\n        -> Maybe (Tagged a)\n    tagIfValidTags array value =\n        case\n            array\n                |> Arr.fromArray\n                |> InArr.isLengthAtMost nat50 { lowest = nat0 }\n        of\n            Nat.EqualOrLess atMost53 ->\n                tag value atMost53 |> Just\n\n            Nat.Above _ ->\n                Nothing\n\n","type":"Nat.Nat (Nat.N upperBound atLeastUpperBound (Nat.Is (Nats.Nat1Plus greaterRange_) Nat.To maxLength) is_) -> { lowest : Nat.Nat (Nat.N lowest atLeastLowest_ (Nat.Is lowestToMin_ Nat.To minLength) (Nat.Is minToUpperBound_ Nat.To upperBound)) } -> Arr.Arr (Nat.In minLength maxLength) element -> Nat.AtMostOrAbove (Arr.Arr (Nat.In lowest atLeastUpperBound) element) (Arr.Arr (Nat.In (Nats.Nat1Plus upperBound) maxLength) element)"},{"name":"isLengthInRange","comment":" Compared to a range from a lower to an upper bound, is its length `BelowOrInOrAboveRange`?\n\n`lowest` can be a number <= the minimum length.\n\n    chooseFormation :\n        Arr (In minLength_ Nat50) Character\n        -> Formation\n    chooseFormation characters =\n        case\n            characters\n                |> InArr.isLengthInRange nat10 nat20 { lowest = nat0 }\n        of\n            Nat.InRange between10And20 ->\n                SpecialAttack between10And20\n\n            Nat.BelowRange atMost9 ->\n                Retreat atMost9\n\n            Nat.AboveRange atLeast21 ->\n                Fight atLeast21\n\n","type":"Nat.Nat (Nat.N lowerBound (Nats.Nat1Plus atLeastLowerBoundMinus1) (Nat.Is lowerBoundToUpperBound_ Nat.To upperBound) lowerBoundIs_) -> Nat.Nat (Nat.N upperBound atLeastUpperBound (Nat.Is upperBoundToMax_ Nat.To maxLength) upperBoundIs_) -> { lowest : Nat.Nat (Nat.N lowest atLeastLowest_ (Nat.Is lowestToMin_ Nat.To minLength) (Nat.Is minToLowerBound_ Nat.To lowerBound)) } -> Arr.Arr (Nat.In minLength maxLength) element -> Nat.BelowOrInOrAboveRange (Arr.Arr (Nat.In lowest atLeastLowerBoundMinus1) element) (Arr.Arr (Nat.In lowerBound atLeastUpperBound) element) (Arr.Arr (Nat.In (Nats.Nat1Plus upperBound) maxLength) element)"},{"name":"prepend","comment":" Add elements of an `Arr` with an exact amount of elements to the left.\n\n    Arr.from3 1 2 3\n        |> InArr.prepend nat3 (Arr.from3 4 5 6)\n    --> Arr.from6 4 5 6 1 2 3\n\n","type":"Nat.Nat (Nat.N added atLeastAdded_ (Nat.Is minLength Nat.To minLengthSum) (Nat.Is maxLength Nat.To maxLengthSum)) -> Arr.Arr (Nat.Only added) element -> Arr.Arr (Nat.In minLength maxLength) element -> Arr.Arr (Nat.In minLengthSum maxLengthSum) element"},{"name":"prependIn","comment":" Add elements of an `Arr` which has multiple possible amounts to the left.\n\n    Arr.from3 1 2 3\n        |> InArr.prependIn nat3 nat5\n            between3And5Elements\n    --> : Arr (In Nat6 (Nat8Plus a))\n\nUse [`prepend`](InArr#prepend) if the appended `Arr` has an exact amount of elements.\n\n","type":"Nat.Nat (Nat.N addedMin atLeastAddedMin_ (Nat.Is minLength Nat.To minLengthSum) addedMinIs_) -> Nat.Nat (Nat.N addedMax atLeastAddedMax_ (Nat.Is maxLength Nat.To maxLengthSum) addedMaxIs_) -> Arr.Arr (Nat.In addedMin addedMax) element -> Arr.Arr (Nat.In minLength maxLength) element -> Arr.Arr (Nat.In minLengthSum maxLengthSum) element"},{"name":"push","comment":" Equivalent to `insertAt nat0 LastToFirst`. Put a new element after all the others.\n\n    between5And10Elements\n        |> InArr.push \"becomes the last\"\n    --> : Arr (In Nat6 (Nat11Plus a_)) String\n\n","type":"element -> Arr.Arr (Nat.In minLength maxLength) element -> Arr.Arr (Nat.In (Nats.Nat1Plus minLength) (Nats.Nat1Plus maxLength)) element"},{"name":"removeAt","comment":" Kick an element out of the `Arr` at a given index in a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/).\n\n    removeLast between1And10Elements =\n        between1And10Elements\n            |> InArr.removeAt nat0 LastToFirst\n\n","type":"Nat.Nat (Nat.ArgIn indexMin_ minLengthMinus1 indexIfN_) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In (Nats.Nat1Plus minLengthMinus1) (Nats.Nat1Plus maxLengthMinus1)) element -> Arr.Arr (Nat.In minLengthMinus1 maxLengthMinus1) element"},{"name":"serialize","comment":" A [`Codec`](https://package.elm-lang.org/packages/MartinSStewart/elm-serialize/latest/) to serialize `Arr`s with a specific amount of elements.\n\n    import Serialize exposing (Codec)\n\n    serializeGameRow :\n        Codec\n            String\n            (Arr (Only Nat10) GameField)\n    serializeGameRow =\n        Arr.serialize nat10\n            -- if we just want a simple error string\n            Arr.errorToString\n            serializeGameField\n\nThe encode/decode functions can be extracted if needed.\n\n    encodeGameRow : Arr (Only Nat10) GameField -> Bytes\n    encodeGameRow =\n        Serialize.encodeToBytes serializeGameRow\n\n    decodeGameRow :\n        Bytes\n        ->\n            Result\n                (Serialize.Error String)\n                (Arr (Only Nat10) GameField)\n    decodeGameRow =\n        Serialize.decodeFromBytes serializeGameRow\n\n","type":"Nat.Nat (Nat.ArgIn minLength maxLength ifN_) -> ({ expected : { length : Nat.Nat (Nat.Min Nats.Nat0) }, actual : { length : Nat.Nat (Nat.Min Nats.Nat0) } } -> error) -> Serialize.Codec error element -> Serialize.Codec error (Arr.Arr (Nat.In minLength maxLength) element)"},{"name":"serializeIn","comment":" A [`Codec`](https://package.elm-lang.org/packages/MartinSStewart/elm-serialize/latest/) to serialize `Arr`s within a minimum & maximum length.\nTo serialize `Arr`s of an exact length, use [`serialize`](InArr#serialize).\n\n    import Serialize exposing (Codec)\n\n    serialize10To15Ints :\n        Codec\n            String\n            (Arr (In Nat10 (Nat15Plus a_)) Int)\n    serialize10To15Ints =\n        InArr.serializeIn\n            nat10\n            nat15\n            -- if we just want a simple error string\n            InArr.errorToString\n            Serialize.int\n\nThe encode/decode functions can be extracted if needed.\n\n    encode :\n        Arr (In (Nat10Plus minMinus10_) Nat15) Int\n        -> Bytes\n    encode =\n        Arr.lowerMinLength nat10\n            >> Serialize.encodeToBytes serialize10To15Ints\n\n    decode :\n        Bytes\n        ->\n            Result\n                (Serialize.Error String)\n                (Arr (In Nat10 (Nat15Plus a_) Int))\n    decode =\n        Serialize.decodeFromBytes serialize10To15Ints\n\nFor decoded `Arr`s with a length outside of the expected bounds, the `Result` is an error message.\n\n","type":"Nat.Nat (Nat.ArgIn minLowerBound minUpperBound lowerBoundIfN_) -> Nat.Nat (Nat.ArgIn minUpperBound maxUpperBound upperBoundIfN_) -> ({ expected : Arr.Expectation, actual : { length : Nat.Nat (Nat.Min Nats.Nat0) } } -> error) -> Serialize.Codec error element -> Serialize.Codec error (Arr.Arr (Nat.In minLowerBound maxUpperBound) element)"}],"binops":[]},{"name":"MinArr","comment":" If the length is `Min` or the maximum length is a type variable:\n\n    first :\n        Arr (In (Nat1Plus minMinus1_) max_) element\n        -> element\n\nuse these operations instead of the ones in [`Arr`](Arr) or [`InArr`](InArr).\n\n\n# modify\n\n@docs push, removeAt, insertAt\n@docs intersperse\n\n\n## glue\n\n@docs append, prepend\n\n\n## part\n\n@docs drop\n\n\n# scan length\n\n@docs isLength, isLengthAtLeast, isLengthAtMost\n\n\n# transform\n\n\n## serialize\n\n@docs serialize\n\n\n## error\n\n@docs Error, generalizeError, errorToString\n\n","unions":[],"aliases":[{"name":"Error","comment":" An error for when a decoded array has a length that's less than the expected minimum length. You can transform it into\n\n  - a message: [`errorToString`](MinArr#errorToString)\n  - an [`Arr.Error`](Arr#Error): [`generalizeError`](MinArr#generalizeError)\n\nSee [`serialize`](MinArr#serialize).\n\n","args":[],"type":"{ expected : { length : { atLeast : Nat.Nat (Nat.Min Nats.Nat0) } }, actual : { length : Nat.Nat (Nat.Min Nats.Nat0) } }"}],"values":[{"name":"append","comment":" Attach elements of an `Arr` to the right.\n\n    Arr.from3 1 2 3\n        |> MinArr.append nat3\n            atLeast3Elements\n    --> : Arr (Min Nat6) ...\n\n","type":"Nat.Nat (Nat.N minAdded atLeastMinAdded_ (Nat.Is minLength Nat.To minLengthSum) is_) -> Arr.Arr (Nat.In minAdded maxAdded_) element -> Arr.Arr (Nat.In minLength maxLength_) element -> Arr.Arr (Nat.Min minLengthSum) element"},{"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    atLeast6Elements\n        |> MinArr.drop nat2 LastToFirst\n    --> : Arr (Min Nat4) ...\n\n","type":"Nat.Nat (Nat.N dropped_ atLeastDropped_ (Nat.Is minTaken Nat.To minLength) is_) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In minLength maxLength) element -> Arr.Arr (Nat.In minTaken maxLength) element"},{"name":"errorToString","comment":" Convert the [serialization](https://package.elm-lang.org/packages/MartinSStewart/elm-serialize/latest/) error into a readable message.\n\n    { expected = { length = { atLeast = nat11 } }\n    , actual = { length = 10 }\n    }\n        |> MinArr.errorToString\n    --> \"Expected an array of length >= 11, but the actual length was 10.\"\n\n(example doesn't compile)\n\nEquivalent to\n\n    error\n        |> MinArr.generalizeError\n        |> Arr.errorToString\n\n","type":"MinArr.Error -> String.String"},{"name":"generalizeError","comment":" Convert its error to a [`Arr.Error`](Arr#Error): an error type that covers all cases where `Array` to `Arr` conversions can fail.\n\n    import Serialize exposing (Codec)\n\n    Serialize.mapError MinArr.generalizeError\n    --> : Codec MinArr.Error a -> Codec Arr.Error a\n\nUse this if you serialize `Arr (In ...)` together with `Arr (Min ...)`:\n\n    Serialize.tuple\n        (MinArr.serialize nat10 ...)\n        (InArr.serializeIn nat10 nat99 ...)\n    --> error : `Codec`s have different custom errors\n\n    Serialize.tuple\n        (MinArr.serialize nat10 ...\n            |> Serialize.mapError MinArr.generalizeError\n        )\n        (InArr.serializeIn nat10 nat99 ...)\n    --> Codec\n    -->     Arr.Error\n    -->     ( Arr (Min Nat0) ...\n    -->     , Arr (In Nat0 (Nat99Plus a_)) ...\n    -->     )\n\nNote: There's also [`errorToString`](MinArr#errorToString).\n\n","type":"MinArr.Error -> Arr.Error"},{"name":"insertAt","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    atLeast5Elements\n        |> MinArr.insertAt nat0 LastToFirst\n            \"becomes the last\"\n    --> : Arr (Min Nat6) String\n\n    cons :\n        element\n        -> Arr (In minLength maxLength_) element\n        -> Arr (Min (Nat1Plus minLength)) element\n    cons =\n        MinArr.insertAt nat0 FirstToLast\n\n","type":"Nat.Nat (Nat.ArgIn indexMin_ minLength indexIfN_) -> LinearDirection.LinearDirection -> element -> Arr.Arr (Nat.In minLength maxLength_) element -> Arr.Arr (Nat.Min (Nats.Nat1Plus minLength)) element"},{"name":"intersperse","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    atLeast3Turtles\n        |> MinArr.intersperse \"on\" nat3\n    --> \"turtles\" \"on\" \"turtles\" \"on\" \"turtles\" ...\n    --> : Arr (Min Nat5) String\n\n","type":"element -> Nat.Nat (Nat.N minLength atLeastMinLength_ (Nat.Is minLength Nat.To (Nats.Nat1Plus minDoubleLengthMinus1)) minIs_) -> Arr.Arr (Nat.In minLength maxLength_) element -> Arr.Arr (Nat.Min minDoubleLengthMinus1) element"},{"name":"isLength","comment":" Compare its length to a given exact length. Is it `LessOrEqualOrGreater`?\n\n`lowest` can be a number <= the minimum length.\n\n    convertUserArguments :\n        String\n        -> Result String (Arr (Only Nat3))\n    convertUserArguments =\n        let\n            wordArr =\n                String.words arguments\n                    |> Arr.fromList\n        in\n        case\n            wordArr\n                |> MinArr.isLength nat3 { lowest = nat0 }\n        of\n            Nat.Equal only3 ->\n                Ok only3\n\n            Nat.Less atMost2 ->\n                Err\n                    (\"I need 3 arguments, but there are only \"\n                        ++ String.fromInt (val (Arr.length atMost2))\n                        ++ \".\"\n                    )\n\n            Nat.Greater atLeast4 ->\n                Err\n                    (\"I need exact 3 arguments, so \"\n                        ++ String.fromInt (val (Arr.length atLeast4))\n                        ++ \" is too much.\"\n                    )\n\n","type":"Nat.Nat (Nat.N (Nats.Nat1Plus nMinus1) atLeastN (Nat.Is a_ Nat.To (Nats.Nat1Plus nPlusAMinus1)) is_) -> { lowest : Nat.Nat (Nat.N lowest atLeastLowest_ (Nat.Is lowestToMin_ Nat.To minLength) (Nat.Is minToValueMinus1_ Nat.To nMinus1)) } -> Arr.Arr (Nat.In minLength maxLength_) element -> Nat.LessOrEqualOrGreater (Arr.Arr (Nat.In lowest nPlusAMinus1) element) (Arr.Arr (Nat.In (Nats.Nat1Plus nMinus1) atLeastN) element) (Arr.Arr (Nat.Min (Nats.Nat2Plus nMinus1)) element)"},{"name":"isLengthAtLeast","comment":" Compare its length to a given exact length.\nIs it `BelowOrAtLeast` that value?\n\n`lowest` can be a number <= the minimum length.\n\n    convertUserArguments : String -> Result String (Arr (Min Nat3))\n    convertUserArguments arguments =\n        let\n            wordArr =\n                String.words arguments\n                    |> Arr.fromList\n        in\n        case\n            wordArr\n                |> MinArr.isLengthAtLeast nat3 { lowest = nat0 }\n        of\n            Nat.EqualOrGreater atLeast3 ->\n                Ok atLeast3\n\n            Nat.Below atMost2 ->\n                Err\n                    (\"I need at least 3 arguments, but there are only \"\n                        ++ String.fromInt (val (Arr.length atMost2))\n                        ++ \".\"\n                    )\n\n","type":"Nat.Nat (Nat.ArgIn minLowerBound (Nats.Nat1Plus maxLowerBoundMinus1) ifN_) -> { lowest : Nat.Nat (Nat.N lowest atLeastLowest_ (Nat.Is lowestToMin_ Nat.To minLength) (Nat.Is lowestToMinLowerBound_ Nat.To minLowerBound)) } -> Arr.Arr (Nat.In minLength maxLength_) element -> Nat.BelowOrAtLeast (Arr.Arr (Nat.In lowest maxLowerBoundMinus1) element) (Arr.Arr (Nat.Min minLowerBound) element)"},{"name":"isLengthAtMost","comment":" Is its length `AtMostOrAbove` a given length?\n\n`lowest` can be a number <= the minimum length.\n\n    -- only up to 50 tags\n    tag : Arr (In min Nat50) String -> a -> Tagged a\n\n    tagIfValidTags : Array String -> a -> Maybe (Tagged a)\n    tagIfValidTags array value =\n        case\n            array\n                |> Arr.fromArray\n                |> MinArr.isLengthAtMost nat50 { lowest = nat0 }\n        of\n            Nat.EqualOrLess atMost50 ->\n                tag value atMost50 |> Just\n\n            Nat.Above _ ->\n                Nothing\n\n","type":"Nat.Nat (Nat.ArgIn minUpperBound maxUpperBound ifN_) -> { lowest : Nat.Nat (Nat.N lowest atLeastLowest_ (Nat.Is lowestToMin_ Nat.To minLength) (Nat.Is lowestToMinUpperBound_ Nat.To minUpperBound)) } -> Arr.Arr (Nat.In minLength maxLength_) element -> Nat.AtMostOrAbove (Arr.Arr (Nat.In lowest maxUpperBound) element) (Arr.Arr (Nat.Min (Nats.Nat1Plus minUpperBound)) element)"},{"name":"prepend","comment":" Add elements of an `Arr` to the left.\n\n    Arr.from3 1 2 3\n        |> MinArr.prepend nat3\n            atLeast3Elements\n    --> : Arr (Min Nat6) ...\n\n","type":"Nat.Nat (Nat.N minAdded atLeastMinAdded_ (Nat.Is minLength Nat.To minLengthSum) is_) -> Arr.Arr (Nat.In minAdded maxAdded_) element -> Arr.Arr (Nat.In minLength maxLength_) element -> Arr.Arr (Nat.Min minLengthSum) element"},{"name":"push","comment":" Put a new element after the others.\n\n    atLeast5Elements\n        |> MinArr.push \"becomes the last\"\n    --> : Arr (Min Nat6) String\n\n","type":"element -> Arr.Arr (Nat.In minLength maxLength_) element -> Arr.Arr (Nat.Min (Nats.Nat1Plus minLength)) element"},{"name":"removeAt","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 atLeast1Element =\n        atLeast1Element\n            |> MinArr.removeAt nat0 LastToFirst\n\n","type":"Nat.Nat (Nat.ArgIn indexMin_ minLengthMinus1 indexIfN_) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In (Nats.Nat1Plus minLengthMinus1) maxLength) element -> Arr.Arr (Nat.In minLengthMinus1 maxLength) element"},{"name":"serialize","comment":" A [`Codec`](https://package.elm-lang.org/packages/MartinSStewart/elm-serialize/latest/) to serialize `Arr`s with a minimum amount of elements.\n\n    import Serialize exposing (Codec)\n\n\n    -- we can't start if we have no worlds to choose from\n    serializeSaves : Codec String (Arr (Min Nat1) World)\n    serializeSaves =\n        MinArr.serialize nat1\n            -- if we just want a simple error string\n            MinArr.errorToString\n            serializeWorld\n\nThe encode/decode functions can be extracted if needed.\n\n    encode : Arr (In (Nat1Plus minMinus1_) max_) World -> Bytes\n    encode =\n        Arr.lowerMinLength nat1\n            >> Arr.toMin\n            >> Serialize.encodeToBytes serializeSaves\n\n    decode :\n        Bytes\n        ->\n            Result\n                (Serialize.Error String)\n                (Arr (Min Nat1) World)\n    decode =\n        Serialize.decodeFromBytes serializeSaves\n\n","type":"Nat.Nat (Nat.ArgIn minLength max_ ifN_) -> ({ expected : { length : { atLeast : Nat.Nat (Nat.Min Nats.Nat0) } }, actual : { length : Nat.Nat (Nat.Min Nats.Nat0) } } -> error) -> Serialize.Codec error element -> Serialize.Codec error (Arr.Arr (Nat.Min minLength) element)"}],"binops":[]}]