Put a new element after the others.

arrWith5To10Elements
    |> InArr.push "becomes the last"
--> : Arr (In Nat6 (Nat11Plus a_)) String

Append the elements of an Arr (Only ...).

Arr.from3 1 2 3
    |> extend nat3 (Arr.from3 4 5 6)
--> Arr.from6 1 2 3 4 5 6

Append the elements of another Arr (In ...).

Arr.from3 1 2 3
    |> extendIn nat3 nat5 arrWith3To5Elements
--> : Arr (In Nat6 (Nat8Plus a))

Kick an element out of the Arr at a given index in a direction.

removeLast arrWith1To10Elements =
    arrWith1To10Elements
        |> InArr.removeAt nat0 LastToFirst

Put an element in the Arr at a given index in a direction.

Arr.from3 'a' 'c' 'd'
    |> InArr.insertAt nat1 FirstToLast 'b'
--> Arr.from4 'a' 'b' 'c' 'd'


Arr.from3 'a' 'c' 'd'
    |> Array.insertAt nat2 LastToFirst 'b'
--> Array.from4 'a' 'b' 'c' 'd'

Elements after a certain number of elements in a direction.

with6To10Elements
    |> InArr.drop nat2 LastToFirst
--> : Arr (In Nat4 (Nat10Plus a)) ...

Compared to a range from a lower to an upper bound, is its length BelowOrInOrAboveRange?

lowest can be a number <= the minimum length.

chooseFormation :
    Arr (In min Nat50) Character
    -> Formation
chooseFormation characters =
    case
        characters
            |> InArr.isLengthInRange nat10 nat20 { lowest = nat0 }
    of
        Nat.InRange between10And20 ->
            SpecialAttack between10And20


        Nat.BelowRange atMost9 ->
            Retreat atMost9


        Nat.AboveRange atLeast21 ->
            Fight atLeast21

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

lowest can be a number <= the minimum length.

chooseFormation :
    Arr (In min Nat50) Character
    -> Formation
chooseFormation characters =
    case
        characters
            |> InArr.isLength nat7 { lowest = nat0 }
    of
        Nat.Equal only7 ->
            SpecialAttack only7


        Nat.Less atMost6 ->
            Retreat atMost6


        Nat.Greater atLeast8 ->
            Fight atLeast8

Is its length BelowOrAtLeast as big as a Nat?

lowest can be a number <= the minimum length.

first5 :
    Arr (In min max) element
    -> Maybe (Arr (In Nat5 max) element)
first5 arr =
    case
        arr |> MinArr.isLengthAtLeast nat5 { lowest = nat0 }
    of
        Nat.Below _ ->
            Nothing


        Nat.EqualOrGreater atLeast5 ->
            Just atLeast5

Is its length AtMostOrAbove a given length?

lowest can be a number <= the minimum length.

-- at least 3 and only up to 50 tags
tag :
    Arr (In (Nat3Plus orHigherMin) Nat50) String
    -> a
    -> Tagged a


tagIfValidTags :
    Arr (In (Nat3Plus orHigherMin) max)
    -> a
    -> Maybe (Tagged a)
tagIfValidTags array value =
    case
        array
            |> Arr.fromArray
            |> InArr.isLengthAtMost nat50 { lowest = nat0 }
    of
        Nat.EqualOrLess atMost53 ->
            tag value atMost53 |> Just


        Nat.Above _ ->
            Nothing

A Codec to serialize Arrs within a minimum & maximum length.

import Serialize


serialize10To15Ints :
    Serialize.Codec
        String
        (Arr (In Nat10 (Nat15Plus a_)) Int)
serialize10To15Ints =
    InArr.serialize Serialize.int nat10 nat15


encode :
    Arr (In (Nat10Plus orHigherMin_) Nat15) Int
    -> Bytes
encode =
    Arr.lowerMinLength nat10
        >> Serialize.encodeToBytes serialize10To15Ints


decode :
    Bytes
    ->
        Result
            (Serialize.Error String)
            (Arr (In Nat10 (Nat15Plus a_) Int))
decode =
    Serialize.decodeFromBytes serialize10To15Ints

For decoded Arrs with a length outside of the expected bounds, the Result is an error message.