[{"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> 0 to 100 joined by a space\n\n    joinBy between =\n        \\before after -> before ++ between ++ after\n\n    let\n        intStringsAfter =\n            Array.fromList (List.range 1 100)\n                String.fromInt\n    in\n    Array.foldl (joinBy \" \") \"0\" intStringsAfter\n    --> \"0 1 2 3 4 5 ...\"\n\n    Arr.nats nat100\n        |> Arr.map (val >> String.fromInt)\n        |> Arr.foldWith FirstToLast (joinBy \" \")\n    --> \"0 1 2 3 4 5 ...\"\n\nThe `Array` version just seems hacky and is less readable. `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, 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\n\n\n### modify\n\n@docs replaceAt, updateAt\n\n\n## part\n\n@docs take, groupsOf, takeMax\n\n\n## transform\n\n@docs map, fold, toArray, foldWith, reverse, resize\n\n\n### combine\n\n@docs map2, map3, map4\n\n\n## drop information\n\n@docs lowerMinLength\n\n\n## restore information\n\n@docs restoreMaxLength\n\n\n## extra\n\n@docs serialize\n\n","unions":[],"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\nFor example to store in your `Model`\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)"}],"values":[{"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 1 2 3 4\n        |> Arr.at nat1 FirstToLast\n    --> 2\n\n    Arr.from4 1 2 3 4\n        |> Arr.at nat1 LastToFirst\n    --> 3\n\n","type":"Nat.Nat (Nat.ArgIn indexMin_ minMinus1 indexIfN_) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In (TypeNats.Nat1Plus minMinus1) max_) element -> 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 TypeNats.Nat0 atLeast0_) element_"},{"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","type":"LinearDirection.LinearDirection -> (element -> result -> result) -> result -> Arr.Arr length_ element -> result"},{"name":"foldWith","comment":" A fold where the initial result is the first value in the `Arr`, looking from a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/).\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\nOften, calling `map` before `foldWith` is helpful.\n\n    Arr.map String.fromInt\n        >> Arr.foldWith FirstToLast (++)\n\ninstead of\n\n    Arr.fold FirstToLast\n        (\\int -> (++) (String.fromInt int))\n        \"\"\n\n","type":"LinearDirection.LinearDirection -> (element -> element -> element) -> Arr.Arr (Nat.In (TypeNats.Nat1Plus minMinus1_) max_) element -> element"},{"name":"from1","comment":" Create an `Arr` with exactly 1 element.\n","type":"element -> Arr.Arr (Nat.In TypeNats.Nat1 (TypeNats.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 TypeNats.Nat10 (TypeNats.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 TypeNats.Nat11 (TypeNats.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 TypeNats.Nat12 (TypeNats.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 TypeNats.Nat13 (TypeNats.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 TypeNats.Nat14 (TypeNats.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 TypeNats.Nat15 (TypeNats.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 TypeNats.Nat16 (TypeNats.Nat16Plus a_)) element"},{"name":"from2","comment":" Create an `Arr` with exactly 2 elements in this order.\n","type":"element -> element -> Arr.Arr (Nat.In TypeNats.Nat2 (TypeNats.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 TypeNats.Nat3 (TypeNats.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 TypeNats.Nat4 (TypeNats.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 TypeNats.Nat5 (TypeNats.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 TypeNats.Nat6 (TypeNats.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 TypeNats.Nat7 (TypeNats.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 TypeNats.Nat8 (TypeNats.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 TypeNats.Nat9 (TypeNats.Nat9Plus a_)) element"},{"name":"fromArray","comment":" Create an `Arr` from an `Array`. As 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 TypeNats.Nat0) 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 which aren't enough\n    }\n\n    Arr.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 : Arr (In Nat0 (Nat5Plus c_)) number\n    --> }\n\n    Arr.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","type":"Nat.Nat (Nat.ArgIn (TypeNats.Nat1Plus minGroupSizeMinus1) maxGroupSize groupSizeIfN_) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In min_ max) element -> { groups : Arr.Arr (Nat.In TypeNats.Nat0 max) (Arr.Arr (Nat.In (TypeNats.Nat1Plus minGroupSizeMinus1) maxGroupSize) element), remaining : Arr.Arr (Nat.In TypeNats.Nat0 maxGroupSize) element }"},{"name":"length","comment":" The amount of elements.\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 lowerMin min lowerIfN_) -> Arr.Arr (Nat.In min max) element -> Arr.Arr (Nat.In lowerMin max) 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 =\n        (+) ('a' |> Char.toCode)\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":"(aElement -> mappedElement) -> Arr.Arr length aElement -> 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    teamLifes aBoard bBoard =\n        Arr.map2 (\\a b -> a.lifes + b.lifes)\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.lifes + b.lifes)\n    (aBoard |> MinArr.value)\n    (bBoard |> MinArr.value)\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.lifes + b.lifes)\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":" 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":" 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. In the end, there are `length` numbers. Use [nats](Arr#nats) if you know the maximum length.\n\n    Arr.nats nat5\n\n    Arr.nats between2And10\n\nIf not:\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 minLength maxLength lengthIfN_) -> Arr.Arr (Nat.In minLength maxLength) (Nat.Nat (Nat.In TypeNats.Nat0 maxLength))"},{"name":"nats","comment":" Increasing natural numbers. In the end, there are `length` numbers.\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 dont 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 minLength (TypeNats.Nat1Plus maxLengthMinus1) lengthIfN_) -> Arr.Arr (Nat.In minLength (TypeNats.Nat1Plus maxLengthMinus1)) (Nat.Nat (Nat.In TypeNats.Nat0 maxLengthMinus1))"},{"name":"random","comment":" Generate a given `amount` of elements and put them in an `Arr`.\n","type":"Nat.Nat (Nat.ArgIn min max ifN_) -> Random.Generator element -> Random.Generator (Arr.Arr (Nat.In min max) 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    --> : Arr (In Nat4 (Nat4Plus a)) Char\n\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\n","type":"Nat.Nat (Nat.ArgIn indexMin_ minLengthMinus1 indexIfN_) -> LinearDirection.LinearDirection -> element -> Arr.Arr (Nat.In (TypeNats.Nat1Plus minLengthMinus1) max) element -> Arr.Arr (Nat.In (TypeNats.Nat1Plus minLengthMinus1) max) 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    --> Array.from4 0 0 1 2\n\n    Arr.resize LastToFirst nat2 0\n        (Array.from3 1 2 3)\n    --> Array.from2 2 3\n\n    Arr.resize FirstToLast nat4 0\n        (Array.from2 1 2)\n    --> Array.from4 1 2 0 0\n\n    Arr.resize FirstToLast nat2 0\n        (Array.from3 1 2 3)\n    --> Array.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 newMin newMax ifN_) -> element -> Arr.Arr (Nat.In min_ max_) element -> Arr.Arr (Nat.In newMin newMax) 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":" Flip the order of the elements.\n\n    Arr.from5 \"l\" \"i\" \"v\" \"e\"\n        |> Arr.reverse\n    --> Arr.from5 \"e\" \"v\" \"i\" \"l\"\n\n","type":"Arr.Arr length element -> Arr.Arr length 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\n\n\n    -- we can't start if we have no worlds to choose from!\n    serializeGameRow :\n        Serialize.Codec\n            String\n            (Arr (Only Nat10) GameField)\n    serializeGameRow =\n        Arr.serialize nat10 serializeGameField\n\n    encode : Arr (Only Nat10) GameField -> Bytes\n    encode =\n        Serialize.encodeToBytes serializeGameRow\n\n    decode :\n        Bytes\n        ->\n            Result\n                (Serialize.Error String)\n                (Arr (Only Nat10) GameField)\n    decode =\n        Serialize.decodeFromBytes serializeGameRow\n\n","type":"Nat.Nat (Nat.ArgIn min max ifN_) -> Serialize.Codec String.String element -> Serialize.Codec String.String (Arr.Arr (Nat.In min max) 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 (In Nat3 Nat7) ...\n\n","type":"Nat.Nat (Nat.N taken atLeastTaken (Nat.Is takenToMin_ Nat.To min) is_) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In min max_) 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.take nat3 nat3 LastToFirst\n    --> Arr.from3 5 6 7\n\n    Arr.from8 0 1 2 3 4 5 6 7\n        |> Arr.takeMax nat7 between3And7 FirstToLast\n    --> : Arr (In Nat3 Nat7) ...\n\nThe first number is the maximum taken amount. The second number is the amount of taken elements.\n\n","type":"Nat.Nat (Nat.N maxTaken atLeastMaxTaken (Nat.Is maxTakenToMin_ Nat.To min) is_) -> Nat.Nat (Nat.ArgIn minTaken maxTaken takenIfN_) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In min max_) element -> Arr.Arr (Nat.In minTaken atLeastMaxTaken) 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","type":"Arr.Arr length_ element -> Array.Array 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 10 20 -30\n        |> Arr.updateAt nat0 LastToFirst (\\x -> -x)\n    --> Arr.from3 10 20 30\n\n","type":"Nat.Nat (Nat.ArgIn indexMin_ minLengthMinus1 indexIfN_) -> LinearDirection.LinearDirection -> (element -> element) -> Arr.Arr (Nat.In (TypeNats.Nat1Plus minLengthMinus1) max) element -> Arr.Arr (Nat.In (TypeNats.Nat1Plus minLengthMinus1) max) element"}],"binops":[]},{"name":"InArr","comment":" If the maximum length is set to a specific value (also for `Only`),\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` or `MinArr`.\n\n\n## modify\n\n@docs push, extend, extendIn, removeAt, insertAt, drop\n\n\n## scan length\n\n@docs isLengthInRange, isLength, isLengthAtLeast, isLengthAtMost\n\n\n## extra\n\n@docs serialize\n\n","unions":[],"aliases":[],"values":[{"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    with6To10Elements\n        |> InArr.drop nat2 LastToFirst\n    --> : Arr (In Nat4 (Nat10Plus a)) ...\n\n","type":"Nat.Nat (Nat.N dropped_ atLeastDropped_ (Nat.Is minTaken Nat.To min) (Nat.Is maxTaken Nat.To max)) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In min max) element -> Arr.Arr (Nat.In minTaken maxTaken) element"},{"name":"extend","comment":" Append the elements of an `Arr (Only ...)`.\n\n    Arr.from3 1 2 3\n        |> extend 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 min Nat.To sumMin) (Nat.Is max Nat.To sumMax)) -> Arr.Arr (Nat.Only added) element -> Arr.Arr (Nat.In min max) element -> Arr.Arr (Nat.In sumMin sumMax) element"},{"name":"extendIn","comment":" Append the elements of another `Arr (In ...)`.\n\n    Arr.from3 1 2 3\n        |> extendIn nat3 nat5 arrWith3To5Elements\n    --> : Arr (In Nat6 (Nat8Plus a))\n\n","type":"Nat.Nat (Nat.N addedMin atLeastAddedMin_ (Nat.Is min Nat.To extendedMin) addedMinIs_) -> Nat.Nat (Nat.N addedMax atLeastAddedMax_ (Nat.Is max Nat.To extendedMax) addedMaxIs_) -> Arr.Arr (Nat.In addedMin addedMax) element -> Arr.Arr (Nat.In min max) element -> Arr.Arr (Nat.In extendedMin extendedMax) element"},{"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 minMinus1 indexIfN_) -> LinearDirection.LinearDirection -> element -> Arr.Arr (Nat.In (TypeNats.Nat1Plus minMinus1) max) element -> Arr.Arr (Nat.In (TypeNats.Nat2Plus minMinus1) (TypeNats.Nat1Plus max)) 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 (TypeNats.Nat1Plus valueMinus1) atLeastValue (Nat.Is a_ Nat.To (TypeNats.Nat1Plus atLeastValueMinus1)) (Nat.Is valueToMax_ Nat.To max)) -> { lowest : Nat.Nat (Nat.N lowest atLeastLowest_ (Nat.Is lowestToMin_ Nat.To min) (Nat.Is minToValue_ Nat.To (TypeNats.Nat1Plus valueMinus1))) } -> Arr.Arr (Nat.In min max) element -> Nat.LessOrEqualOrGreater (Arr.Arr (Nat.In lowest atLeastValueMinus1) element) (Arr.Arr (Nat.In (TypeNats.Nat1Plus valueMinus1) atLeastValue) element) (Arr.Arr (Nat.In (TypeNats.Nat2Plus valueMinus1) max) 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 min max) element\n        -> Maybe (Arr (In Nat5 max) element)\n    first5 arr =\n        case\n            arr |> MinArr.isLengthAtLeast nat5 { lowest = nat0 }\n        of\n            Nat.Below _ ->\n                Nothing\n\n            Nat.EqualOrGreater atLeast5 ->\n                Just atLeast5\n\n","type":"Nat.Nat (Nat.N lowerBound (TypeNats.Nat1Plus atLeastLowerBoundMinus1) (Nat.Is atLeastRange_ Nat.To max) is_) -> { lowest : Nat.Nat (Nat.N lowest atLeastLowest (Nat.Is lowestToMin Nat.To min) (Nat.Is (TypeNats.Nat1Plus lowestToLowerBound_) Nat.To lowerBound)) } -> Arr.Arr (Nat.In min max) element -> Nat.BelowOrAtLeast (Arr.Arr (Nat.In lowest atLeastLowerBoundMinus1) element) (Arr.Arr (Nat.In lowerBound max) 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 (TypeNats.Nat1Plus greaterRange_) Nat.To max) is_) -> { lowest : Nat.Nat (Nat.N lowest atLeastLowest_ (Nat.Is lowestToMin_ Nat.To min) (Nat.Is minToUpperBound_ Nat.To upperBound)) } -> Arr.Arr (Nat.In min max) element -> Nat.AtMostOrAbove (Arr.Arr (Nat.In lowest atLeastUpperBound) element) (Arr.Arr (Nat.In (TypeNats.Nat1Plus upperBound) max) 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 min 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 (TypeNats.Nat1Plus atLeastLowerBoundMinus1) (Nat.Is lowerBoundToUpperBound_ Nat.To upperBound) lowerBoundIs_) -> Nat.Nat (Nat.N upperBound atLeastUpperBound (Nat.Is upperBoundToMax_ Nat.To max) upperBoundIs_) -> { lowest : Nat.Nat (Nat.N lowest atLeastLowest_ (Nat.Is lowestToMin_ Nat.To min) (Nat.Is minToLowerBound_ Nat.To lowerBound)) } -> Arr.Arr (Nat.In min max) element -> Nat.BelowOrInOrAboveRange (Arr.Arr (Nat.In lowest atLeastLowerBoundMinus1) element) (Arr.Arr (Nat.In lowerBound atLeastUpperBound) element) (Arr.Arr (Nat.In (TypeNats.Nat1Plus upperBound) max) element)"},{"name":"push","comment":" Put a new element after the others.\n\n    arrWith5To10Elements\n        |> InArr.push \"becomes the last\"\n    --> : Arr (In Nat6 (Nat11Plus a_)) String\n\n","type":"element -> Arr.Arr (Nat.In min max) element -> Arr.Arr (Nat.In (TypeNats.Nat1Plus min) (TypeNats.Nat1Plus max)) 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 arrWith1To10Elements =\n        arrWith1To10Elements\n            |> InArr.removeAt nat0 LastToFirst\n\n","type":"Nat.Nat (Nat.ArgIn indexMin minMinus1 indexIfN_) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In (TypeNats.Nat1Plus minMinus1) (TypeNats.Nat1Plus maxMinus1)) element -> Arr.Arr (Nat.In minMinus1 maxMinus1) element"},{"name":"serialize","comment":" A [`Codec`](https://package.elm-lang.org/packages/MartinSStewart/elm-serialize/latest/) to serialize `Arr`s within a minimum & maximum length.\n\n    import Serialize\n\n    serialize10To15Ints :\n        Serialize.Codec\n            String\n            (Arr (In Nat10 (Nat15Plus a_)) Int)\n    serialize10To15Ints =\n        InArr.serialize Serialize.int nat10 nat15\n\n    encode :\n        Arr (In (Nat10Plus orHigherMin_) 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_) -> Serialize.Codec String.String element -> Serialize.Codec String.String (Arr.Arr (Nat.In minLowerBound maxUpperBound) element)"}],"binops":[]},{"name":"MinArr","comment":" If the maximum length is a type variable,\n\n    first :\n        Arr (In (Nat1Plus orHigherMin) max) element\n        -> element\n\nuse these operations instead of the ones in `Arr` or `InArr`\n\n\n## modify\n\n@docs push, removeAt, insertAt, extend, drop\n\n\n## scan length\n\n@docs isLength, isLengthAtLeast, isLengthAtMost\n\n\n## drop information\n\n@docs value\n\n\n## extra\n\n@docs serialize\n\n","unions":[],"aliases":[],"values":[{"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    withAtLeast6Elements\n        |> MinArr.drop nat2 LastToFirst\n    --> : Arr (Min Nat4) ...\n\n","type":"Nat.Nat (Nat.N dropped_ atLeastDropped_ (Nat.Is minTaken Nat.To min) is_) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In min max) element -> Arr.Arr (Nat.In minTaken max) element"},{"name":"extend","comment":" Append an `Arr`.\n\n    Arr.from3 1 2 3\n        |> MinArr.extend nat3 arrWithAtLeast3Elements\n    --> : Arr (Min Nat6) ...\n\n","type":"Nat.Nat (Nat.N minAdded atLeastMinAdded_ (Nat.Is min Nat.To sumMin) is_) -> Arr.Arr (Nat.In minAdded maxAdded) element -> Arr.Arr (Nat.In min max) element -> Arr.Arr (Nat.Min sumMin) element"},{"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    arrWithAtLeast5Elements\n        |> MinArr.insertAt nat0 FirstToLast\n            \"becomes the first\"\n    --> : Arr (Min Nat6) String\n\n","type":"Nat.Nat (Nat.ArgIn indexMin_ minLengthMinus1 indexIfN_) -> LinearDirection.LinearDirection -> element -> Arr.Arr (Nat.In (TypeNats.Nat1Plus minLengthMinus1) maxLength_) element -> Arr.Arr (Nat.Min (TypeNats.Nat2Plus minLengthMinus1)) 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                    |> Array.fromList\n                    |> Arr.fromArray\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 (TypeNats.Nat1Plus valueMinus1) atLeastValue (Nat.Is a_ Nat.To (TypeNats.Nat1Plus atLeastValueMinus1)) is_) -> { lowest : Nat.Nat (Nat.N lowest atLeastLowest_ (Nat.Is lowestToMin_ Nat.To min) (Nat.Is minToValueMinus1_ Nat.To valueMinus1)) } -> Arr.Arr (Nat.In min max_) element -> Nat.LessOrEqualOrGreater (Arr.Arr (Nat.In lowest atLeastValueMinus1) element) (Arr.Arr (Nat.In (TypeNats.Nat1Plus valueMinus1) atLeastValue) element) (Arr.Arr (Nat.Min (TypeNats.Nat2Plus valueMinus1)) 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                    |> Array.fromList\n                    |> Arr.fromArray\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 (TypeNats.Nat1Plus maxLowerBoundMinus1) ifN_) -> { lowest : Nat.Nat (Nat.N lowest atLeastLowest_ (Nat.Is lowestToMin_ Nat.To min) (Nat.Is lowestToMinLowerBound_ Nat.To minLowerBound)) } -> Arr.Arr (Nat.In min max_) 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 min) (Nat.Is lowestToMinUpperBound_ Nat.To minUpperBound)) } -> Arr.Arr (Nat.In min max_) element -> Nat.AtMostOrAbove (Arr.Arr (Nat.In lowest maxUpperBound) element) (Arr.Arr (Nat.Min (TypeNats.Nat1Plus minUpperBound)) element)"},{"name":"push","comment":" Put a new element after the others.\n\n    arrWithAtLeast5Elements\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 (TypeNats.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 arrWithAtLeast1Element =\n        arrWithAtLeast1Element\n            |> MinArr.removeAt nat0 LastToFirst\n\n","type":"Nat.Nat (Nat.ArgIn indexMin_ minLengthMinus1 indexIfN_) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In (TypeNats.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\n\n\n    -- we can't start if we have no worlds to choose from!\n    serializeSaves : Serialize.Codec String (Arr (Min Nat1) World)\n    serializeSaves =\n        MinArr.serialize nat1 serializeWorld\n\n    encode : Arr (In (Nat1Plus minMinus1_) max_) World -> Bytes\n    encode =\n        MinArr.value\n            >> Arr.lowerMinLength nat1\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 min max_ ifN_) -> Serialize.Codec String.String element -> Serialize.Codec String.String (Arr.Arr (Nat.Min min) element)"},{"name":"value","comment":" Convert the `Arr (In min ...)` to a `Arr (Min min)`.\n\n    between4And10Elements |> MinArr.value\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 |> MinArr.value\n    ]\n\n","type":"Arr.Arr (Nat.In min max_) element -> Arr.Arr (Nat.Min min) element"}],"binops":[]}]