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 exposing (Codec)




-- we can't start if we have no worlds to choose from
serializeSaves : Codec String (Arr (Min Nat1) World)
serializeSaves =
    MinArr.serialize nat1
        -- if we just want a simple error string
        MinArr.errorToString
        serializeWorld

The encode/decode functions can be extracted if needed.

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


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

An error for when a decoded array has a length that's less than the expected minimum length. You can transform it into

• a message: errorToString
• an Arr.Error: generalizeError

See serialize.

Convert its error to a Arr.Error: an error type that covers all cases where Array to Arr conversions can fail.

import Serialize exposing (Codec)


Serialize.mapError MinArr.generalizeError
--> : Codec MinArr.Error a -> Codec Arr.Error a

Use this if you serialize Arr (In ...) together with Arr (Min ...):

Serialize.tuple
    (MinArr.serialize nat10 ...)
    (InArr.serializeIn nat10 nat99 ...)
--> error : `Codec`s have different custom errors


Serialize.tuple
    (MinArr.serialize nat10 ...
        |> Serialize.mapError MinArr.generalizeError
    )
    (InArr.serializeIn nat10 nat99 ...)
--> Codec
-->     Arr.Error
-->     ( Arr (Min Nat0) ...
-->     , Arr (In Nat0 (Nat99Plus a_)) ...
-->     )

Note: There's also errorToString.

Convert the serialization error into a readable message.

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

(example doesn't compile)

Equivalent to

error
    |> MinArr.generalizeError
    |> Arr.errorToString