Put a new element after the others.

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

Kick out the element at an index in a direction.

removeLast atLeast1Element =
    atLeast1Element
        |> MinArr.removeAt nat0 LastToFirst

Put a new element at an index in a direction.

atLeast5Elements
    |> MinArr.insertAt nat0 LastToFirst
        "becomes the last"
--> : Arr (Min Nat6) String


cons :
    element
    -> Arr (In minLength maxLength_) element
    -> Arr (Min (Nat1Plus minLength)) element
cons =
    MinArr.insertAt nat0 FirstToLast

Attach elements of an Arr to the right.

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

Add elements of an Arr to the left.

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

Elements after a certain number of elements in a direction.

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

Compare its length to a given exact length. Is it LessOrEqualOrGreater?

lowest can be a number <= the minimum length.

convertUserArguments :
    String
    -> Result String (Arr (Only Nat3))
convertUserArguments =
    let
        wordArr =
            String.words arguments
                |> Arr.fromList
    in
    case
        wordArr
            |> MinArr.isLength nat3 { lowest = 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 its length to a given exact length. Is it BelowOrAtLeast that value?

lowest can be a number <= the minimum length.

convertUserArguments : String -> Result String (Arr (Min Nat3))
convertUserArguments arguments =
    let
        wordArr =
            String.words arguments
                |> Arr.fromList
    in
    case
        wordArr
            |> MinArr.isLengthAtLeast nat3 { lowest = 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 its length AtMostOrAbove a given length?

lowest can be a number <= 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 { lowest = nat0 }
    of
        Nat.EqualOrLess atMost50 ->
            tag value atMost50 |> Just


        Nat.Above _ ->
            Nothing

Convert the Arr (In min ...) to a Arr (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 : Codec String (Arr (Min Nat1) World)
serializeSaves =
    MinArr.serialize nat1
        -- just give us the error back as a String
        MinArr.serializeErrorToString
        serializeWorld

The encode/decode functions can be extracted if needed.

encode : Arr (In (Nat1Plus minMinus1_) max_) World -> Bytes
encode =
    MinArr.value
        >> Arr.lowerMinLength nat1
        >> Serialize.encodeToBytes serializeSaves


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

Convert the serialization error into a readable message.

{ expectedLength = { atLeast = nat11 }
, actualLength = 10
}
    |> MinArr.serializeErrorToString
--> expected an array of length >= 11 but the actual length was 10