[{"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, from2, from3, from4, from10, from11, from12, from13, from14, from15, from16, from5, from6, from7, from8, from9\n\n\n## scan\n\n@docs length, at\n\n\n## part\n\n@docs take, drop\n\n\n## transform\n\n@docs map, fold, toArray, map2, map3, map4, foldWith, reverse\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, restoreLength\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## value / return types\n\n  - amount >= 5\n\n```\nArr (ValueMin Nat5) ...\n```\n\n  - 2 <= amount <= 12\n\n```\nArr (ValueIn Nat2 Nat12) ...\n```\n\n  - = 4\n\n```\nArr (ValueOnly Nat4) ...\n```\n\n  - the exact amount 3, also described as the difference between 2 numbers\n\n```\nArr\n    (ValueN Nat3\n        (Nat3Plus more)\n        (Is a To (Nat3Plus a))\n        (Is b To (Nat3Plus b))\n    )\n```\n\n\n## function argument types\n\n  - amount >= 4\n\n```\nArr (In (Nat4Plus minMinus4) max maybeN) ...\n```\n\n  - 4 <= amount <= 15\n\n```\nArr (In (Nat4Plus minMinus4) Nat15 maybeN) ...\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.from3 1 2 3\n        |> Arr.at nat1\n    --> 2\n\n","type":"Nat.Nat (Nat.In indexMin minMinus1 indexMaybeN) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In (TypeNats.Nat1Plus minMinus1) max maybeN) 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.N dropped (Nat.Is minTaken Nat.To min) (Nat.Is maxTaken Nat.To max)) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In min max maybeN) element -> Arr.Arr (Nat.ValueIn minTaken maxTaken) element"},{"name":"empty","comment":" No elements.\n\n    Arr.empty\n    --> : Arr (ValueN Nat0 ...) element\n        |> NArr.push \":)\"\n    --> : Arr (ValueN Nat1 ...) String\n\n","type":"Arr.Arr (Nat.ValueN TypeNats.Nat0 atLeast0 (Nat.Is a Nat.To a) (Nat.Is b Nat.To b)) 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 maybeExact) 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 maybeN) element -> element"},{"name":"from1","comment":" Create an `Arr (ValueN Nat1 ...)` from exactly 1 element in this order.\n","type":"element -> Arr.Arr (Nat.ValueN TypeNats.Nat1 (TypeNats.Nat1Plus more) (Nat.Is a Nat.To (TypeNats.Nat1Plus a)) (Nat.Is b Nat.To (TypeNats.Nat1Plus b))) element"},{"name":"from10","comment":" Create an `Arr (ValueN Nat10 ...)` from exactly 10 element in this order.\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> Arr.Arr (Nat.ValueN TypeNats.Nat10 (TypeNats.Nat10Plus more) (Nat.Is a Nat.To (TypeNats.Nat10Plus a)) (Nat.Is b Nat.To (TypeNats.Nat10Plus b))) element"},{"name":"from11","comment":" Create an `Arr (ValueN Nat11 ...)` from exactly 11 element in this order.\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> Arr.Arr (Nat.ValueN TypeNats.Nat11 (TypeNats.Nat11Plus more) (Nat.Is a Nat.To (TypeNats.Nat11Plus a)) (Nat.Is b Nat.To (TypeNats.Nat11Plus b))) element"},{"name":"from12","comment":" Create an `Arr (ValueN Nat12 ...)` from exactly 12 element in this order.\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> Arr.Arr (Nat.ValueN TypeNats.Nat12 (TypeNats.Nat12Plus more) (Nat.Is a Nat.To (TypeNats.Nat12Plus a)) (Nat.Is b Nat.To (TypeNats.Nat12Plus b))) element"},{"name":"from13","comment":" Create an `Arr (ValueN Nat13 ...)` from exactly 13 element in this order.\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> Arr.Arr (Nat.ValueN TypeNats.Nat13 (TypeNats.Nat13Plus more) (Nat.Is a Nat.To (TypeNats.Nat13Plus a)) (Nat.Is b Nat.To (TypeNats.Nat13Plus b))) element"},{"name":"from14","comment":" Create an `Arr (ValueN Nat14 ...)` from exactly 14 element in this order.\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> Arr.Arr (Nat.ValueN TypeNats.Nat14 (TypeNats.Nat14Plus more) (Nat.Is a Nat.To (TypeNats.Nat14Plus a)) (Nat.Is b Nat.To (TypeNats.Nat14Plus b))) element"},{"name":"from15","comment":" Create an `Arr (ValueN Nat15 ...)` from exactly 15 element in this order.\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> Arr.Arr (Nat.ValueN TypeNats.Nat15 (TypeNats.Nat15Plus more) (Nat.Is a Nat.To (TypeNats.Nat15Plus a)) (Nat.Is b Nat.To (TypeNats.Nat15Plus b))) element"},{"name":"from16","comment":" Create an `Arr (ValueN Nat16 ...)` from exactly 16 element in this order.\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> element -> Arr.Arr (Nat.ValueN TypeNats.Nat16 (TypeNats.Nat16Plus more) (Nat.Is a Nat.To (TypeNats.Nat16Plus a)) (Nat.Is b Nat.To (TypeNats.Nat16Plus b))) element"},{"name":"from2","comment":" Create an `Arr (ValueN Nat2 ...)` from exactly 2 element in this order.\n","type":"element -> element -> Arr.Arr (Nat.ValueN TypeNats.Nat2 (TypeNats.Nat2Plus more) (Nat.Is a Nat.To (TypeNats.Nat2Plus a)) (Nat.Is b Nat.To (TypeNats.Nat2Plus b))) element"},{"name":"from3","comment":" Create an `Arr (ValueN Nat3 ...)` from exactly 3 element in this order.\n","type":"element -> element -> element -> Arr.Arr (Nat.ValueN TypeNats.Nat3 (TypeNats.Nat3Plus more) (Nat.Is a Nat.To (TypeNats.Nat3Plus a)) (Nat.Is b Nat.To (TypeNats.Nat3Plus b))) element"},{"name":"from4","comment":" Create an `Arr (ValueN Nat4 ...)` from exactly 4 element in this order.\n","type":"element -> element -> element -> element -> Arr.Arr (Nat.ValueN TypeNats.Nat4 (TypeNats.Nat4Plus more) (Nat.Is a Nat.To (TypeNats.Nat4Plus a)) (Nat.Is b Nat.To (TypeNats.Nat4Plus b))) element"},{"name":"from5","comment":" Create an `Arr (ValueN Nat5 ...)` from exactly 5 element in this order.\n","type":"element -> element -> element -> element -> element -> Arr.Arr (Nat.ValueN TypeNats.Nat5 (TypeNats.Nat5Plus more) (Nat.Is a Nat.To (TypeNats.Nat5Plus a)) (Nat.Is b Nat.To (TypeNats.Nat5Plus b))) element"},{"name":"from6","comment":" Create an `Arr (ValueN Nat6 ...)` from exactly 6 element in this order.\n","type":"element -> element -> element -> element -> element -> element -> Arr.Arr (Nat.ValueN TypeNats.Nat6 (TypeNats.Nat6Plus more) (Nat.Is a Nat.To (TypeNats.Nat6Plus a)) (Nat.Is b Nat.To (TypeNats.Nat6Plus b))) element"},{"name":"from7","comment":" Create an `Arr (ValueN Nat7 ...)` from exactly 7 element in this order.\n","type":"element -> element -> element -> element -> element -> element -> element -> Arr.Arr (Nat.ValueN TypeNats.Nat7 (TypeNats.Nat7Plus more) (Nat.Is a Nat.To (TypeNats.Nat7Plus a)) (Nat.Is b Nat.To (TypeNats.Nat7Plus b))) element"},{"name":"from8","comment":" Create an `Arr (ValueN Nat8 ...)` from exactly 8 element in this order.\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> Arr.Arr (Nat.ValueN TypeNats.Nat8 (TypeNats.Nat8Plus more) (Nat.Is a Nat.To (TypeNats.Nat8Plus a)) (Nat.Is b Nat.To (TypeNats.Nat8Plus b))) element"},{"name":"from9","comment":" Create an `Arr (ValueN Nat9 ...)` from exactly 9 element in this order.\n","type":"element -> element -> element -> element -> element -> element -> element -> element -> element -> Arr.Arr (Nat.ValueN TypeNats.Nat9 (TypeNats.Nat9Plus more) (Nat.Is a Nat.To (TypeNats.Nat9Plus a)) (Nat.Is b Nat.To (TypeNats.Nat9Plus b))) element"},{"name":"fromArray","comment":" Create an `Arr` from an `Array`. As every `Array` has `>= 0` elements:\n\n    Arr.fromArray arrayFromSomewhere\n    --> : Arr (ValueMin 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.ValueMin TypeNats.Nat0) 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 (ValueMin Nat3) ...`\n\n    [ atLeast3Elements\n    , atLeast4Elements\n        |> Arr.lowerMinLength nat3\n    ]\n\n","type":"Nat.Nat (Nat.In lowerMin min lowerMaybeN) -> Arr.Arr (Nat.In min max maybeN) element -> Arr.Arr (Nat.ValueIn lowerMin max) element"},{"name":"map","comment":" Change every element.\n\n    aToZ =\n        Arr.nats nat26\n            |> Arr.map\n                ((+) ('a' |> Char.toCode)\n                    >> Char.fromCode\n                )\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\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    -->     (ValueN Nat10 ...)\n    -->     (Nat (ValueIn Nat0 (Nat9Plus a)))\n\n    from first length_ =\n        Arr.nats length_\n            |> Arr.map (InNat.add first)\n\n","type":"Nat.Nat (Nat.In (TypeNats.Nat1Plus minLengthMinus1) (TypeNats.Nat1Plus maxLengthMinus1) lengthMaybeN) -> Arr.Arr (Nat.In (TypeNats.Nat1Plus minLengthMinus1) (TypeNats.Nat1Plus maxLengthMinus1) lengthMaybeN) (Nat.Nat (Nat.ValueIn TypeNats.Nat0 maxLengthMinus1))"},{"name":"random","comment":" Generate a given `amount` of elements and put them in an `Arr`.\n","type":"Nat.Nat length -> Random.Generator element -> Random.Generator (Arr.Arr length 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 (ValueN Nat4 ...) Char\n\n\n    Arr.repeat atLeast3 'L'\n    --> : Arr (ValueMin Nat3) Char\n\n","type":"Nat.Nat length -> element -> Arr.Arr length 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.In indexMin minLengthMinus1 indexMaybeN) -> LinearDirection.LinearDirection -> element -> Arr.Arr (Nat.In (TypeNats.Nat1Plus minLengthMinus1) max maybeN) element -> Arr.Arr (Nat.In (TypeNats.Nat1Plus minLengthMinus1) max maybeN) element"},{"name":"restoreLength","comment":" Transform a potential `ValueOnly` `Arr` to a `ValueN`.\n\n    append10s :\n        Arr (Only Nat10 aMaybeN) element\n        -> Arr (Only Nat10 bMaybeN) element\n        -> Arr (ValueN Nat20 (Nat20Plus a) ...)\n    append10s a10Elements b10Elements =\n        a10Elements\n            |> InArr.extend nat10 nat10 b10Elements\n            |> Arr.restoreLength nat20\n\n","type":"Nat.Nat (Nat.ValueN n atLeastN aDifference bDifference) -> Arr.Arr (Nat.Only n maybeN) element -> Arr.Arr (Nat.ValueN n atLeastN aDifference bDifference) 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 maybeN) ...\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.N max (Nat.Is a Nat.To atLeastMax) x) -> Arr.Arr (Nat.In min max maybeN) element -> Arr.Arr (Nat.In min atLeastMax maybeN) 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 (ValueN Nat10 ...) GameField)\n    serializeGameRow =\n        Arr.serialize nat10 serializeGameField\n\n    encode : Arr (Only Nat10 maybeN) GameField -> Bytes\n    encode =\n        Arr.restoreLength nat10\n            >> Serialize.encodeToBytes serializeGameRow\n\n    decode :\n        Bytes\n        ->\n            Result\n                (Serialize.Error String)\n                (Arr (ValueN Nat10 ...) GameField)\n    decode =\n        Serialize.decodeFromBytes serializeGameRow\n\n","type":"Nat.Nat length -> Serialize.Codec String.String element -> Serialize.Codec String.String (Arr.Arr length 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 (ValueIn Nat3 Nat7) ...\n\n","type":"Nat.Nat (Nat.In minTaken maxTaken takenMaybeN) -> Nat.Nat (Nat.N maxTaken (Nat.Is a Nat.To atLeastMaxTaken) (Nat.Is maxTakenToMin Nat.To min)) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In min max maybeN) element -> Arr.Arr (Nat.In minTaken atLeastMaxTaken takenMaybeN) 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 `Only`),\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, extendN, removeAt, insertAt\n\n\n## scan length\n\n@docs isLengthInRange, 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 the elements of another `Arr (In ...)`.\n","type":"Arr.Arr (Nat.In extensionMin extensionMax extensionMaybeN) element -> Nat.Nat (Nat.N extensionMin (Nat.Is min Nat.To extendedMin) x) -> Nat.Nat (Nat.N extensionMax (Nat.Is max Nat.To extendedMax) y) -> Arr.Arr (Nat.In min max maybeN) element -> Arr.Arr (Nat.ValueIn extendedMin extendedMax) element"},{"name":"extendN","comment":" Append the elements of a `Arr (N ...)`.\n","type":"Arr.Arr (Nat.N added (Nat.Is min Nat.To sumMin) (Nat.Is max Nat.To sumMax)) element -> Arr.Arr (Nat.In min max maybeN) element -> Arr.Arr (Nat.ValueIn 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.In indexMin minMinus1 indexMaybeN) -> LinearDirection.LinearDirection -> element -> Arr.Arr (Nat.In (TypeNats.Nat1Plus minMinus1) max maybeN) element -> Arr.Arr (Nat.ValueIn (TypeNats.Nat2Plus minMinus1) (TypeNats.Nat1Plus max)) element"},{"name":"isLength","comment":" Compare the length to an exact `Nat (N ...)` length.\nAre there `more`, `less` or an `equal` amount of elements?\n\n`min` ensures that the `Nat (N ...)` is greater than the minimum length.\n\n    chooseFormation :\n        Arr (ValueIn 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 (ValueOnly Nat7) Character)\n        | Retreat (Arr (ValueIn Nat0 Nat6) Character)\n        | Fight (Arr (ValueIn Nat8 Nat50) Character)\n\n","type":"Nat.Nat (Nat.N tried (Nat.Is triedToMax Nat.To max) (Nat.Is a Nat.To (TypeNats.Nat1Plus atLeastTriedMinus1))) -> { min : Nat.Nat (Nat.N min (Nat.Is minToTried Nat.To tried) x) } -> { equal : Arr.Arr (Nat.ValueOnly tried) element -> result, greater : Arr.Arr (Nat.In (TypeNats.Nat2Plus triedMinus1) max maybeN) element -> result, less : Arr.Arr (Nat.In min atLeastTriedMinus1 maybeN) element -> result } -> Arr.Arr (Nat.In min max maybeN) 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.N lowerBound (Nat.Is a Nat.To (TypeNats.Nat1Plus atLeastTriedMinus1)) (Nat.Is atLeastRange Nat.To max)) -> { min : Nat.Nat (Nat.N min (Nat.Is (TypeNats.Nat1Plus lessRange) Nat.To lowerBound) x) } -> { less : Arr.Arr (Nat.In min atLeastTriedMinus1 maybeN) element -> result, equalOrGreater : Arr.Arr (Nat.In lowerBound max maybeN) element -> result } -> Arr.Arr (Nat.In min max maybeN) 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.N upperBound (Nat.Is a Nat.To atLeastUpperBound) (Nat.Is (TypeNats.Nat1Plus greaterRange) Nat.To max)) -> { min : Nat.Nat (Nat.N min (Nat.Is minToUpperBound Nat.To upperBound) x) } -> { equalOrLess : Arr.Arr (Nat.In min atLeastUpperBound maybeN) element -> result, greater : Arr.Arr (Nat.In (TypeNats.Nat1Plus upperBound) max maybeN) element -> result } -> Arr.Arr (Nat.In min max maybeN) 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 (ValueIn 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 (ValueIn Nat10 Nat20) Character)\n        | Retreat (Arr (ValueIn Nat0 Nat9) Character)\n        | Fight (Arr (ValueIn Nat21 Nat50) Character)\n\n","type":"Nat.Nat (Nat.N lowerBound (Nat.Is lowerBoundToUpperBound Nat.To upperBound) (Nat.Is lowerBoundA Nat.To (TypeNats.Nat1Plus atLeastLowerBoundMinus1))) -> Nat.Nat (Nat.N upperBound (Nat.Is upperBoundToMax Nat.To max) (Nat.Is upperBoundA Nat.To atLeastUpperBound)) -> { min : Nat.Nat (Nat.N min (Nat.Is minToLowerBound Nat.To lowerBound) x) } -> { inRange : Arr.Arr (Nat.In lowerBound atLeastUpperBound maybeN) element -> result, less : Arr.Arr (Nat.In min atLeastLowerBoundMinus1 maybeN) element -> result, greater : Arr.Arr (Nat.In (TypeNats.Nat1Plus upperBound) max maybeN) element -> result } -> Arr.Arr (Nat.In min max maybeN) element -> result"},{"name":"push","comment":" Put a new element after the others.\n\n    arrWith5To10Elements\n        |> InArr.push \"becomes the last\"\n    --> : Arr (ValueIn Nat6 Nat11) String\n\n","type":"element -> Arr.Arr (Nat.In min max maybeN) element -> Arr.Arr (Nat.ValueIn (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.In indexMin minMinus1 indexMaybeN) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In (TypeNats.Nat1Plus minMinus1) (TypeNats.Nat1Plus maxMinus1) maybeN) element -> Arr.Arr (Nat.ValueIn 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 (ValueIn 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 (ValueIn 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.In minLowerBound upperBound lowerBoundMaybeN) -> Nat.Nat (Nat.In upperBound upperBoundPlusA upperBoundMaybeN) -> Serialize.Codec String.String element -> Serialize.Codec String.String (Arr.Arr (Nat.ValueIn minLowerBound upperBoundPlusA) element)"},{"name":"value","comment":" Convert it to an `Arr (ValueIn min max)`.\n\n    Arr.from3 1 2 3 |> InArr.value\n    --> : Nat (ValueIn Nat3 (Nat3Plus a))\n\nThere is only 1 situation you should use this.\n\nTo make these the same type.\n\n    [ arrWith3To10Elements\n    , Arr.repeat nat3 0\n    ]\n\nElm complains:\n\n> But all the previous elements in the list are\n> `Arr (ValueIn Nat3 Nat10) ...`\n\n    [ arrWith3To10Elements\n    , Arr.repeat nat3 0 |> InArr.value\n    ]\n\n","type":"Arr.Arr (Nat.In min max maybeExact) element -> Arr.Arr (Nat.ValueIn min max) 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, extendN\n\n\n## scan length\n\n@docs isLength, isLengthAtLeast, isLengthAtMost\n\n\n## transform\n\n@docs group\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 (ValueMin Nat6) ...\n\n","type":"Arr.Arr (Nat.In extensionMin extensionMax extensionMaybeN) element -> Nat.Nat (Nat.N extensionMin (Nat.Is min Nat.To extendedMin) x) -> Arr.Arr (Nat.In min max maybeN) element -> Arr.Arr (Nat.ValueMin extendedMin) element"},{"name":"extendN","comment":" Append a fixed length `Arr (N ...)`.\n\n    arrWithAtLeast3Elements\n        |> MinArr.extendN (Arr.from3 5 6 7)\n    --> : Arr (ValueMin Nat6) ...\n\n","type":"Arr.Arr (Nat.N added (Nat.Is min Nat.To sumMin) x) element -> Arr.Arr (Nat.In min max maybeN) element -> Arr.Arr (Nat.ValueMin sumMin) element"},{"name":"group","comment":" Split\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.group 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.In (TypeNats.Nat1Plus minGroupSizMinus1) maxGroupSize groupSizeMaybeN) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In min max maybeN) element -> { groups : Arr.Arr (Nat.ValueIn TypeNats.Nat0 max) (Arr.Arr (Nat.In (TypeNats.Nat1Plus minGroupSizMinus1) maxGroupSize groupSizeMaybeN) element), less : Arr.Arr (Nat.ValueIn TypeNats.Nat0 max) 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 (ValueMin Nat6) String\n\n","type":"Nat.Nat (Nat.In indexMin minLengthMinus1 indexMaybeN) -> LinearDirection.LinearDirection -> element -> Arr.Arr (Nat.In (TypeNats.Nat1Plus minLengthMinus1) maxLength maybeN) element -> Arr.Arr (Nat.ValueMin (TypeNats.Nat2Plus minLengthMinus1)) element"},{"name":"isLength","comment":" Compare the length to an exact `Nat (N ...)`.\nIs it `greater`, `less` or `equal`?\n\n`min` ensures that the `Nat (N ...)` is bigger than the minimum length.\n\n    convertUserArguments :\n        String\n        -> Result String (Arr (ValueN 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.N (TypeNats.Nat1Plus triedMinus1) (Nat.Is a Nat.To (TypeNats.Nat1Plus triedMinus1PlusA)) x) -> { min : Nat.Nat (Nat.N min (Nat.Is minToTriedMinus1 Nat.To triedMinus1) y) } -> { equal : Arr.Arr (Nat.ValueOnly (TypeNats.Nat1Plus triedMinus1)) element -> result, greater : Arr.Arr (Nat.ValueMin (TypeNats.Nat2Plus triedMinus1)) element -> result, less : Arr.Arr (Nat.In min triedMinus1PlusA maybeN) element -> result } -> Arr.Arr (Nat.In min max maybeN) element -> result"},{"name":"isLengthAtLeast","comment":" Compare the length to an exact `Nat (N ...)`.\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 (ValueMin 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.N lowerBound (Nat.Is a Nat.To (TypeNats.Nat1Plus lowerBoundMinus1PlusA)) x) -> { min : Nat.Nat (Nat.N min (Nat.Is minToTriedMin Nat.To lowerBound) y) } -> { equalOrGreater : Arr.Arr (Nat.ValueMin lowerBound) element -> result, less : Arr.Arr (Nat.In min lowerBoundMinus1PlusA maybeN) element -> result } -> Arr.Arr (Nat.In min max maybeN) 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.N upperBound (Nat.Is a Nat.To upperBoundPlusA) x) -> { min : Nat.Nat (Nat.N min (Nat.Is minToAtMostMin Nat.To upperBound) y) } -> { equalOrLess : Arr.Arr (Nat.In min upperBoundPlusA maybeN) element -> result, greater : Arr.Arr (Nat.ValueMin (TypeNats.Nat1Plus upperBound)) element -> result } -> Arr.Arr (Nat.In min max maybeN) element -> result"},{"name":"push","comment":" Put a new element after the others.\n\n    arrWithAtLeast5Elements\n        |> MinArr.push \"becomes the last\"\n    --> : Arr (ValueMin Nat6) String\n\n","type":"element -> Arr.Arr (Nat.In min max maybeN) element -> Arr.Arr (Nat.ValueMin (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.In indexMin minLengthMinus1 indexMaybeExact) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.In (TypeNats.Nat1Plus minLengthMinus1) maxLength maybeN) element -> Arr.Arr (Nat.ValueIn 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 (ValueMin 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 (ValueMin Nat1) World)\n    decode =\n        Serialize.decodeFromBytes serializeSaves\n\n","type":"Nat.Nat (Nat.N lowerBound (Nat.Is a Nat.To (TypeNats.Nat1Plus lowerBoundMinus1PlusA)) x) -> Serialize.Codec String.String element -> Serialize.Codec String.String (Arr.Arr (Nat.ValueMin lowerBound) element)"},{"name":"value","comment":" Convert an exact Arr (In min ...) to a Nat (ValueMin min).\n\n    between4And10Elements |> MinArr.value\n    --> : Arr (ValueMin 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 (ValueMin Nat1) ...`\n\n    [ atLeast1Element\n    , between1And10Elements |> MinArr.value\n    ]\n\n","type":"Arr.Arr (Nat.In min max maybeN) element -> Arr.Arr (Nat.ValueMin min) element"}],"binops":[]},{"name":"NArr","comment":"\n\n\n## modify\n\n@docs push, extend, removeAt\n\n","unions":[],"aliases":[],"values":[{"name":"extend","comment":" Append an `Arr N` containing a fixed amount of elements.\n\n    sixEmptySlots =\n        Arr.repeat nat6 0\n\n    Arr.from2 1 2\n        |> NArr.extend nat6 sixEmptySlots\n    --> Arr.from6 1 2 0 0 0 0 0 0\n\n","type":"Nat.Nat (Nat.N added (Nat.Is n Nat.To sum) (Nat.Is atLeastN Nat.To atLeastSum)) -> Arr.Arr (Nat.N added (Nat.Is aPlusN Nat.To aPlusSum) (Nat.Is bPlusN Nat.To bPlusSum)) element -> Arr.Arr (Nat.ValueN n atLeastN (Nat.Is a Nat.To aPlusN) (Nat.Is b Nat.To bPlusN)) element -> Arr.Arr (Nat.ValueN sum atLeastSum (Nat.Is a Nat.To aPlusSum) (Nat.Is b Nat.To bPlusSum)) element"},{"name":"push","comment":" Put a new element after the others.\n\n    Arr.from5 1 2 3 4 5\n        |> Arr.push 6\n    --> Arr.from6 1 2 3 4 5 6\n\n","type":"element -> Arr.Arr (Nat.ValueN n atLeastN (Nat.Is a Nat.To nPlusA) (Nat.Is b Nat.To nPlusB)) element -> Arr.Arr (Nat.ValueN (TypeNats.Nat1Plus n) (TypeNats.Nat1Plus atLeastN) (Nat.Is a Nat.To (TypeNats.Nat1Plus nPlusA)) (Nat.Is b Nat.To (TypeNats.Nat1Plus nPlusB))) element"},{"name":"removeAt","comment":" Kick an element out of an Arr at a given index in a direction.\n\n    Arr.from3 'a' 'a' 'b'\n        |> InArr.removeAt nat1 FirstToLast\n    --> Arr.from2 'a' 'b'\n\n    Arr.from4 'a' 'b' 'c' 'd'\n        |> InArr.removeAt nat0 LastToFirst\n    --> Arr.from3 'a' 'b' 'c'\n\n","type":"Nat.Nat (Nat.In minIndex lengthMinus1 indexMaybeN) -> LinearDirection.LinearDirection -> Arr.Arr (Nat.ValueN (TypeNats.Nat1Plus lengthMinus1) (TypeNats.Nat1Plus atLeastLength) (Nat.Is a Nat.To (TypeNats.Nat1Plus lengthPlusA)) (Nat.Is b Nat.To (TypeNats.Nat1Plus lengthPlusB))) element -> Arr.Arr (Nat.ValueN lengthMinus1 atLeastLength (Nat.Is a Nat.To lengthPlusA) (Nat.Is b Nat.To lengthPlusB)) element"}],"binops":[]}]