Put a new element after the others.

arrWithAtLeast5Elements
    |> MinArr.push "becomes the last"
--> : Arr (Min Nat6) String

Kick out the element at an index in a direction.

removeLast arrWithAtLeast1Element =
    arrWithAtLeast1Element
        |> MinArr.removeAt nat0 LastToFirst

Put a new element at an index in a direction.

arrWithAtLeast5Elements
    |> MinArr.insertAt nat0 FirstToLast
        "becomes the first"
--> : Arr (Min Nat6) String

Append an Arr (In ...).

Arr.from3 1 2 3
    |> MinArr.extend nat3 arrWithAtLeast3Elements
--> : Arr (Min Nat6) ...

Elements after a certain number of elements from one side.

withAtLeast6Elements
    |> Arr.drop nat2 LastToFirst
--> : Arr (Min Nat4) ...

Compare the length to an exact Nat (ArgN ...). Is it LessOrEqualOrGreater?

min ensures that that Nat (ArgN ...) is bigger than the minimum length.

convertUserArguments :
    String
    -> Result String (Arr (Only Nat3))
convertUserArguments =
    let
        wordArr =
            String.words arguments
                |> Array.fromList
                |> Arr.fromArray
    in
    case wordArr |> MinArr.isLength nat3 { min = nat0 } of
        Nat.Equal only3 ->
            Ok only3


        Nat.Less atMost2 ->
            Err
                ("I need 3 arguments, but there are only "
                    ++ String.fromInt (val (Arr.length atMost2))
                    ++ "."
                )


        Nat.Greater atLeast4 ->
            Err
                ("I need exact 3 arguments, so "
                    ++ String.fromInt (val (Arr.length atLeast4))
                    ++ " is too much."
                )

Compare the length to an exact Nat (ArgN ...). Is it BelowOrAtLeast that value?

min ensures that that Nat is bigger than the minimum length.

convertUserArguments : String -> Result String (Arr (Min Nat3))
convertUserArguments arguments =
    let
        wordArr =
            String.words arguments
                |> Array.fromList
                |> Arr.fromArray
    in
    case wordArr |> MinArr.isLengthAtLeast nat3 { min = nat0 } of
        Nat.EqualOrGreater atLeast3 ->
            Ok atLeast3


        Nat.Below atMost2 ->
            Err
                ("I need at least 3 arguments, but there are only "
                    ++ String.fromInt (val (Arr.length atMost2))
                    ++ "."
                )

Is the length AtMostOrAbove a given Nat?

min ensures that that Nat is greater than the minimum length.

-- only up to 50 tags
tag : Arr (In min Nat50) String -> a -> Tagged a


tagIfValidTags : Array String -> a -> Maybe (Tagged a)
tagIfValidTags array value =
    case
        (array |> Arr.fromArray)
            |> MinArr.isLengthAtMost nat50 { min = nat0 }
    of
        Nat.EqualOrLess atMost50 ->
            tag value atMost50 |> Just


        Nat.Above _ ->
            Nothing

Convert an exact Arr (In min ...) to a Nat (Min min).

between4And10Elements |> MinArr.value
--> : Arr (Min Nat4) ...

There is only 1 situation you should use this.

To make these the same type.

[ atLeast1Element, between1And10Elements ]

Elm complains:

But all the previous elements in the list are Arr (Min Nat1) ...

[ atLeast1Element
, between1And10Elements |> MinArr.value
]

A Codec to serialize Arrs with a minimum amount of elements.

import Serialize




-- we can't start if we have no worlds to choose from!
serializeSaves :
    Serialize.Codec
        String
        (Arr (Min Nat1) World)
serializeSaves =
    MinArr.serialize nat1 serializeWorld


encode : Arr (In (Nat1Plus minMinus1) max) World -> Bytes
encode =
    MinArr.value
        >> Serialize.encodeToBytes serializeSaves


decode :
    Bytes
    ->
        Result
            (Serialize.Error String)
            (Arr (Min Nat1) World)
decode =
    Serialize.decodeFromBytes serializeSaves