[{"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, 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## part\n\n@docs take, drop, groupsOf\n\n\n## transform\n\n@docs map, fold, toArray, foldWith, reverse, resize\n\n\n### map\n\n@docs map2, map3, map4\n\n\n### modify\n\n@docs replaceAt\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 Nat12) ...\n```\n\n  - = 4\n\n```\nArr (Only Nat4) ...\n```\n\n\n### as argument types\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  - = 15\n\n```\nArr (Only Nat15) ...\n```\n\n  - any amount\n\n```\nArr range ...\n```\n\n","args":["length","element"],"type":"Typed.Typed Typed.Checked Internal.Arr.ArrTag Typed.Internal (Internal.Arr.Content length element)"}],"values":[{"name":"at","comment":" Element at a valid position.\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 indexMaybeN) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In (TypeNats.Nat1Plus minMinus1) max) element -> element"},{"name":"drop","comment":" After a certain number of elements from one side.\n\n    with6To10Elements\n        |> Arr.drop nat2 LastToFirst\n    --> : Arr (In Nat4 (Nat10Plus a)) ...\n\nUse `take` `LastToFirst` if you know the exact amount of elements.\n\n","type":"Nat.Nat (Nat.ArgN dropped (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":"empty","comment":" No elements.\n\n    Arr.empty\n    --> : Arr (In Nat0 atLeast0) element\n        |> NArr.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 (Nat.In min max) element -> result"},{"name":"foldWith","comment":" A fold where the initial result is the first value.\n\n    Arr.foldWith FirstToLast maximum\n        (Arr.from3 234 345 543)\n    --> 543\n\n","type":"LinearDirection.LinearDirection -> (element -> element -> element) -> Arr.Arr (Nat.In (TypeNats.Nat1Plus minMinus1) max) element -> element"},{"name":"from1","comment":" Create an `Arr` from exactly 1 elements in this order.\n","type":"element -> Arr.Arr (Nat.In TypeNats.Nat1 (TypeNats.Nat1Plus a)) element"},{"name":"from10","comment":" Create an `Arr` from 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` from 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` from 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` from 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` from 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` from 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` from 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` from 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` from 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` from 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` from 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` from 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` from 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` from 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` from 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\n    Arr.fromArray\n        (Array.fromList [ 0, 1, 2, 3, 4, 5, 6 ])\n    --> big no\n\n    Arr.from7 0 1 2 3 4 5 6\n    --> ok\n\n    Arr.nats nat7\n    --> big yes\n\nTell the compiler if you know the amount of elements. Make sure the it knows as much as you!\n\n","type":"Array.Array element -> Arr.Arr (Nat.Min TypeNats.Nat0) element"},{"name":"groupsOf","comment":" Split the `Arr` into equal-sized chunks.\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        |> MinArr.groupsOf nat5 FirstToLast\n    --> { groups = Arr.from1 (Arr.from5 1 2 3 4 5)\n    --> , less = Arr.from2 6 7\n    --> }\n\nThe type of the result isn't as accurate as in the example, though!\n\n","type":"Nat.Nat (Nat.ArgIn (TypeNats.Nat1Plus minGroupSizMinus1) maxGroupSize groupSizeMaybeN) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In min max) element -> { groups : Arr.Arr (Nat.In TypeNats.Nat0 max) (Arr.Arr (Nat.In (TypeNats.Nat1Plus minGroupSizMinus1) maxGroupSize) element), less : 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 lowerMaybeN) -> Arr.Arr (Nat.In min max) element -> Arr.Arr (Nat.In lowerMin max) element"},{"name":"map","comment":" Change every element.\n\n    aToZ =\n        Arr.nats nat26\n            |> Arr.map\n                (val >> fromPositionInABC)\n\n    fromPositionInABC =\n        (+) ('a' |> Char.toCode)\n            >> Char.fromCode\n\n`val` refers to `Typed.val`.\n\n","type":"(aElement -> bElement) -> Arr.Arr length aElement -> Arr.Arr length bElement"},{"name":"map2","comment":" Combine the elements of 2 `Arr`s to a new element.\nIf one list is longer, the extra elements are dropped.\n\n    teamLifes aBoard bBoard =\n        Arr.map2 (\\a b -> a.lifes + b.lifes)\n            aBoard\n            bBoard\n\nThe length pf all `Arr`s must be in the same range.\n\n  - If 1 `Arr` is a potential `Arr (Min ...)`, you have to\n\n```\nArr.map2 (\\a b -> a.lifes + b.lifes)\n    (aBoard |> MinArr.value)\n    (bBoard |> MinArr.value)\n\naBoard, bBoard : Arr (In Nat2 someMax) Field\n```\n\nfor every non-`Arr (Min ...)`.\n\n  - If 1 `Arr` has a higher minimum length, you have to\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 -> combined) -> Arr.Arr length a -> Arr.Arr length b -> Arr.Arr length combined"},{"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":"nats","comment":" Increasing natural numbers. In the end, there are `length` numbers.\n\n    Arr.nats nat10\n    --> : Arr\n    -->     (N Nat10 ...)\n    -->     (Nat (In Nat0 (Nat9Plus a)))\n\n    from first length_ =\n        Arr.nats length_\n            |> Arr.map (InNat.add first)\n\n","type":"Nat.Nat (Nat.ArgIn (TypeNats.Nat1Plus minLengthMinus1) (TypeNats.Nat1Plus maxLengthMinus1) lengthMaybeN) -> Arr.Arr (Nat.In (TypeNats.Nat1Plus minLengthMinus1) (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 maybeN) -> 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 maybeN) -> element -> Arr.Arr (Nat.In min max) element"},{"name":"replaceAt","comment":" Set the element at an index in a direction.\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 indexMaybeN) -> 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, 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 min max maybeN) -> element -> Arr.Arr length element -> Arr.Arr (Nat.In min max) 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.ArgN max (Nat.Is a Nat.To atLeastMax) x) -> Arr.Arr (Nat.In min max) element -> Arr.Arr (Nat.In min atLeastMax) 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 maybeN) -> Serialize.Codec String.String element -> Serialize.Codec String.String (Arr.Arr (Nat.In min max) element)"},{"name":"take","comment":" This works for both\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.take between3To7 nat7 FirstToLast\n    --> : Arr (In Nat3 Nat7) ...\n\n","type":"Nat.Nat (Nat.ArgIn minTaken maxTaken takenMaybeN) -> Nat.Nat (Nat.ArgN maxTaken (Nat.Is a Nat.To atLeastMaxTaken) (Nat.Is maxTakenToMin Nat.To min)) -> 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"}],"binops":[]},{"name":"InArr","comment":" If the maximum length is set to a specific value (also in `ArgOnly`),\n\n    -- only up to 50 tags\n    tag :\n        Arr (In min Nat50 maybeN) String\n        -> a\n        -> Tagged a\n\nuse these operations instead of the ones in `Arr` or `MinArr`.\n\n\n## modify\n\n@docs push, extend, extendOnly, removeAt, insertAt\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":"extend","comment":" Append the elements of another `Arr (In ...)`.\n","type":"Arr.Arr (Nat.In extensionMin extensionMax) element -> Nat.Nat (Nat.ArgN extensionMin (Nat.Is min Nat.To extendedMin) x) -> Nat.Nat (Nat.ArgN extensionMax (Nat.Is max Nat.To extendedMax) y) -> Arr.Arr (Nat.In min max) element -> Arr.Arr (Nat.In extendedMin extendedMax) element"},{"name":"extendOnly","comment":" Append the elements of an `Arr (Only ...)`.\n","type":"Nat.Nat (Nat.ArgN added (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":"insertAt","comment":" Use `MinArr.push`, if the `max` isn't known to be a certain value.\n","type":"Nat.Nat (Nat.ArgIn indexMin minMinus1 indexMaybeN) -> 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 the length to an exact `Nat (ArgN ...)` length.\nAre there `more`, `less` or an `equal` amount of elements?\n\n`min` ensures that the `Nat (ArgN ...)` is greater than the minimum length.\n\n    chooseFormation :\n        Arr (In Nat0 Nat50) Character\n        -> Formation\n    chooseFormation characters =\n        characters\n            |> InArr.isLength nat7\n                { min = nat0 }\n                { equal = SpecialAttack\n                , less = Retreat\n                , more = Fight\n                }\n\n    type Formation\n        = SpecialAttack (Arr (Only Nat7) Character)\n        | Retreat (Arr (In Nat0 Nat6) Character)\n        | Fight (Arr (In Nat8 Nat50) Character)\n\n","type":"Nat.Nat (Nat.ArgN tried (Nat.Is triedToMax Nat.To max) (Nat.Is a Nat.To (TypeNats.Nat1Plus atLeastTriedMinus1))) -> { min : Nat.Nat (Nat.ArgN min (Nat.Is minToTried Nat.To tried) x) } -> { equal : Arr.Arr (Nat.Only tried) element -> result, greater : Arr.Arr (Nat.In (TypeNats.Nat2Plus triedMinus1) max) element -> result, less : Arr.Arr (Nat.In min atLeastTriedMinus1) element -> result } -> Arr.Arr (Nat.In min max) element -> result"},{"name":"isLengthAtLeast","comment":" Is the length\n\n  - `equalOrGreater` than a lower bound or\n\n  - `less`?\n\n`min` ensures that the lower bound is greater than the minimum length.\n\n    first5 :\n        Arr (In min max maybeN) element\n        -> Maybe (Arr (In Nat5 max maybeN) element)\n    first5 =\n        MinArr.lowerMinLength nat0\n            >> MinArr.isLengthAtLeast nat5\n                { min = nat0 }\n                { less = \\_ -> Nothing\n                , equalOrGreater = Just\n                }\n\n","type":"Nat.Nat (Nat.ArgN lowerBound (Nat.Is a Nat.To (TypeNats.Nat1Plus atLeastTriedMinus1)) (Nat.Is atLeastRange Nat.To max)) -> { min : Nat.Nat (Nat.ArgN min (Nat.Is (TypeNats.Nat1Plus lessRange) Nat.To lowerBound) x) } -> { less : Arr.Arr (Nat.In min atLeastTriedMinus1) element -> result, equalOrGreater : Arr.Arr (Nat.In lowerBound max) element -> result } -> Arr.Arr (Nat.In min max) element -> result"},{"name":"isLengthAtMost","comment":" Is the length\n\n  - `equalOrLess` than a upper bound or\n\n  - `greater`?\n\n`min` ensures that the upper bound is greater than the minimum length.\n\n    -- at least 3 and only up to 50 tags\n    tag :\n        Arr (In (Nat3Plus orHigherMin) Nat50 maybeN) String\n        -> a\n        -> Tagged a\n\n    tagIfValidTags :\n        Arr (In (Nat3Plus orHigherMin) max maybeN)\n        -> a\n        -> Maybe (Tagged a)\n    tagIfValidTags array value =\n        array\n            |> Arr.fromArray\n            |> InArr.isLengthAtMost nat50\n                { equalOrLess = tag value >> Just\n                , greater = \\_ -> Nothing\n                }\n\n","type":"Nat.Nat (Nat.ArgN upperBound (Nat.Is a Nat.To atLeastUpperBound) (Nat.Is (TypeNats.Nat1Plus greaterRange) Nat.To max)) -> { min : Nat.Nat (Nat.ArgN min (Nat.Is minToUpperBound Nat.To upperBound) x) } -> { equalOrLess : Arr.Arr (Nat.In min atLeastUpperBound) element -> result, greater : Arr.Arr (Nat.In (TypeNats.Nat1Plus upperBound) max) element -> result } -> Arr.Arr (Nat.In min max) element -> result"},{"name":"isLengthInRange","comment":" Compared to a range from a lower to an upper bound, is the length\n\n  - `inRange`\n\n  - `greater` than the upper bound or\n\n  - `less` than the lower bound?\n\n`min` ensures that the lower bound is greater than the minimum length.\n\n    chooseFormation :\n        Arr (In Nat0 Nat50) Character\n        -> Formation\n    chooseFormation characters =\n        characters\n            |> InArr.isLengthInRange nat10\n                nat20\n                { min = nat0 }\n                { equal = SpecialAttack\n                , less = Retreat\n                , more = Fight\n                }\n\n    type Formation\n        = SpecialAttack (Arr (In Nat10 Nat20) Character)\n        | Retreat (Arr (In Nat0 Nat9) Character)\n        | Fight (Arr (In Nat21 Nat50) Character)\n\n","type":"Nat.Nat (Nat.ArgN lowerBound (Nat.Is lowerBoundToUpperBound Nat.To upperBound) (Nat.Is lowerBoundA Nat.To (TypeNats.Nat1Plus atLeastLowerBoundMinus1))) -> Nat.Nat (Nat.ArgN upperBound (Nat.Is upperBoundToMax Nat.To max) (Nat.Is upperBoundA Nat.To atLeastUpperBound)) -> { min : Nat.Nat (Nat.ArgN min (Nat.Is minToLowerBound Nat.To lowerBound) x) } -> { inRange : Arr.Arr (Nat.In lowerBound atLeastUpperBound) element -> result, less : Arr.Arr (Nat.In min atLeastLowerBoundMinus1) element -> result, greater : Arr.Arr (Nat.In (TypeNats.Nat1Plus upperBound) max) element -> result } -> Arr.Arr (Nat.In min max) element -> result"},{"name":"push","comment":" Put a new element after the others.\n\n    arrWith5To10Elements\n        |> InArr.push \"becomes the last\"\n    --> : Arr (In Nat6 Nat11) 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 an Arr at a given index in a direction.\n","type":"Nat.Nat (Nat.ArgIn indexMin minMinus1 indexMaybeN) -> 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 maybeN) Int\n        -> Bytes\n    encode =\n        InNat.value\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 upperBound lowerBoundMaybeN) -> Nat.Nat (Nat.ArgIn upperBound upperBoundPlusA upperBoundMaybeN) -> Serialize.Codec String.String element -> Serialize.Codec String.String (Arr.Arr (Nat.In minLowerBound upperBoundPlusA) element)"}],"binops":[]},{"name":"MinArr","comment":" If the maximum length is a type variable,\n\n    first :\n        Arr (In (Nat1Plus orHigherMin) max maybeN) 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\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":"extend","comment":" Append an `Arr (In ...)`.\n\n    Arr.from3 1 2 3\n        |> MinArr.extend nat3 arrWithAtLeast3Elements\n    --> : Arr (Min Nat6) ...\n\n","type":"Arr.Arr (Nat.In extensionMin extensionMax) element -> Nat.Nat (Nat.ArgN extensionMin (Nat.Is min Nat.To extendedMin) x) -> Arr.Arr (Nat.In min max) element -> Arr.Arr (Nat.Min extendedMin) element"},{"name":"insertAt","comment":" Put a new element at an index in a direction.\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 indexMaybeN) -> LinearDirection.LinearDirection -> element -> Arr.Arr (Nat.In (TypeNats.Nat1Plus minLengthMinus1) maxLength) element -> Arr.Arr (Nat.Min (TypeNats.Nat2Plus minLengthMinus1)) element"},{"name":"isLength","comment":" Compare the length to an exact `Nat (ArgN ...)`.\nIs it `greater`, `less` or `equal`?\n\n`min` ensures that the `Nat (ArgN ...)` is bigger than the minimum length.\n\n    convertUserArguments :\n        String\n        -> Result String (Arr (Only Nat3))\n    convertUserArguments =\n        String.words\n            >> Array.fromList\n            >> Arr.fromArray\n            >> MinArr.isLength nat3\n                { min = nat0 }\n                { equal = Ok\n                , less =\n                    \\less ->\n                        Err\n                            (\"I need 3 arguments, but there are only \"\n                                ++ String.fromInt (val (Arr.length less))\n                                ++ \".\"\n                            )\n                , greater =\n                    \\more ->\n                        Err\n                            (\"I need exact 3 arguments, so \"\n                                ++ String.fromInt (val (Arr.length more))\n                                ++ \" is too much.\"\n                            )\n                }\n\n","type":"Nat.Nat (Nat.ArgN (TypeNats.Nat1Plus triedMinus1) (Nat.Is a Nat.To (TypeNats.Nat1Plus triedMinus1PlusA)) x) -> { min : Nat.Nat (Nat.ArgN min (Nat.Is minToTriedMinus1 Nat.To triedMinus1) y) } -> { equal : Arr.Arr (Nat.Only (TypeNats.Nat1Plus triedMinus1)) element -> result, greater : Arr.Arr (Nat.Min (TypeNats.Nat2Plus triedMinus1)) element -> result, less : Arr.Arr (Nat.In min triedMinus1PlusA) element -> result } -> Arr.Arr (Nat.In min max) element -> result"},{"name":"isLengthAtLeast","comment":" Compare the length to an exact `Nat (ArgN ...)`.\nIs it `equalOrGreater` or `less`?\n\n`min` ensures that the lower bound is bigger than the minimum length.\n\n    convertUserArguments :\n        String\n        -> Result String (Arr (Min Nat3))\n    convertUserArguments =\n        String.words\n            >> Array.fromList\n            >> Arr.fromArray\n            >> MinArr.isLengthAtLeast nat3\n                { min = nat0 }\n                { equalOrGreater = Ok\n                , less =\n                    \\less ->\n                        Err\n                            (\"I need at least 3 arguments, but there are only \"\n                                ++ String.fromInt (val (Arr.length less))\n                                ++ \".\"\n                            )\n                }\n\n","type":"Nat.Nat (Nat.ArgN lowerBound (Nat.Is a Nat.To (TypeNats.Nat1Plus lowerBoundMinus1PlusA)) x) -> { min : Nat.Nat (Nat.ArgN min (Nat.Is minToTriedMin Nat.To lowerBound) y) } -> { equalOrGreater : Arr.Arr (Nat.Min lowerBound) element -> result, less : Arr.Arr (Nat.In min lowerBoundMinus1PlusA) element -> result } -> Arr.Arr (Nat.In min max) element -> result"},{"name":"isLengthAtMost","comment":" Is the length\n\n  - `equalOrLess` than an upper bound or\n\n  - `greater`?\n\n`min` ensures that the upper bound is greater than the minimum length.\n\n    -- only up to 50 tags\n    tag :\n        Arr (In min Nat50 maybeN) String\n        -> a\n        -> Tagged a\n\n    tagIfValidTags : Array String -> a -> Maybe (Tagged a)\n    tagIfValidTags array value =\n        array\n            |> Arr.fromArray\n            |> MinArr.isLengthAtMost nat50\n                { equalOrLess = tag value >> Just\n                , greater = \\_ -> Nothing\n                }\n\n","type":"Nat.Nat (Nat.ArgN upperBound (Nat.Is a Nat.To upperBoundPlusA) x) -> { min : Nat.Nat (Nat.ArgN min (Nat.Is minToAtMostMin Nat.To upperBound) y) } -> { equalOrLess : Arr.Arr (Nat.In min upperBoundPlusA) element -> result, greater : Arr.Arr (Nat.Min (TypeNats.Nat1Plus upperBound)) element -> result } -> Arr.Arr (Nat.In min max) element -> result"},{"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 min max) element -> Arr.Arr (Nat.Min (TypeNats.Nat1Plus min)) element"},{"name":"removeAt","comment":" Kick out the element at an index in a direction.\n\n    removeLast arrWithAtLeast1Element =\n        arrWithAtLeast1Element\n            |> MinArr.removeAt nat0 LastToFirst\n\n","type":"Nat.Nat (Nat.ArgIn indexMin minLengthMinus1 indexMaybeExact) -> 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 :\n        Serialize.Codec\n            String\n            (Arr (Min Nat1) World)\n    serializeSaves =\n        MinArr.serialize nat1 serializeWorld\n\n    encode :\n        Arr (In (Nat1Plus minMinus1) max maybeN) World\n        -> Bytes\n    encode =\n        MinArr.value\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.ArgN lowerBound (Nat.Is a Nat.To (TypeNats.Nat1Plus lowerBoundMinus1PlusA)) x) -> Serialize.Codec String.String element -> Serialize.Codec String.String (Arr.Arr (Nat.Min lowerBound) element)"},{"name":"value","comment":" Convert an exact Arr (In min ...) to a Nat (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":[]}]