An Arr describes an array where you know more about the amount of elements.

value / return types

• amount >= 5

Arr (Min Nat5) ...

• 2 <= amount <= 12

Arr (In Nat2 Nat12) ...

• = 4

Arr (Only Nat4) ...

• the exact amount 3, also described as the difference between 2 numbers

Arr
    (N Nat3
        (Nat3Plus more)
        (Is a To (Nat3Plus a))
        (Is b To (Nat3Plus b))
    )

function argument types

• amount >= 4

Arr (In (Nat4Plus minMinus4) max) ...

• 4 <= amount <= 15

Arr (In (Nat4Plus minMinus4) Nat15) ...

• = 15

Arr (Only Nat15) ...

• any amount

Arr range ...

Create an Arr from an Array. As every Array has >= 0 elements:

Arr.fromArray arrayFromSomewhere
--> : Arr (Min Nat0)


Arr.fromArray
    (Array.fromList [ 0, 1, 2, 3, 4, 5, 6 ])
--> big no


Arr.from7 0 1 2 3 4 5 6
--> ok


Arr.nats nat7
--> big yes

Tell the compiler if you know the amount of elements. Make sure the it knows as much as you!

An Arr with a given amount of same elements.

Arr.repeat nat4 'L'
--> Arr.from4 'L' 'L' 'L' 'L'
--> : Arr (N Nat4 ...) Char




Arr.repeat atLeast3 'L'
--> : Arr (Min Nat3) Char

Increasing natural numbers. In the end, there are length numbers.

Arr.nats nat10
--> : Arr
-->     (N Nat10 ...)
-->     (Nat (In Nat0 (Nat9Plus a)))


from first length_ =
    Arr.nats length_
        |> Arr.map (InNat.add first)

Generate a given amount of elements and put them in an Arr.

No elements.

Arr.empty
--> : Arr (N Nat0 ...) element
    |> NArr.push ":)"
--> : Arr (N Nat1 ...) String

Create an Arr (Only Nat1) from exactly 1 elements in this order.

Create an Arr (Only Nat2) from exactly 2 elements in this order.

Create an Arr (Only Nat3) from exactly 3 elements in this order.

Create an Arr (Only Nat4) from exactly 4 elements in this order.

Create an Arr (Only Nat10) from exactly 10 elements in this order.

Create an Arr (Only Nat11) from exactly 11 elements in this order.

Create an Arr (Only Nat12) from exactly 12 elements in this order.

Create an Arr (Only Nat13) from exactly 13 elements in this order.

Create an Arr (Only Nat14) from exactly 14 elements in this order.

Create an Arr (Only Nat15) from exactly 15 elements in this order.

Create an Arr (Only Nat16) from exactly 16 elements in this order.

Create an Arr (Only Nat5) from exactly 5 elements in this order.

Create an Arr (Only Nat6) from exactly 6 elements in this order.

Create an Arr (Only Nat7) from exactly 7 elements in this order.

Create an Arr (Only Nat8) from exactly 8 elements in this order.

Create an Arr (Only Nat9) from exactly 9 elements in this order.

The amount of elements.

Element at a valid position.

Arr.from3 1 2 3
    |> Arr.at nat1
--> 2

This works for both

Arr.from8 0 1 2 3 4 5 6 7
    |> Arr.take nat3 nat3 LastToFirst
--> Arr.from3 5 6 7


Arr.from8 0 1 2 3 4 5 6 7
    |> Arr.take between3To7 nat7 FirstToLast
--> : Arr (In Nat3 Nat7) ...

After a certain number of elements from one side.

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

Use take LastToFirst if you know the exact amount of elements.

Change every element.

aToZ =
    Arr.nats nat26
        |> Arr.map
            ((+) ('a' |> Char.toCode)
                >> Char.fromCode
            )

Reduce an Arr in a direction.

Arr.from5 "l" "i" "v" "e"
    |> Arr.fold FirstToLast (++) ""
--> "live"


Arr.from5 "l" "i" "v" "e"
    |> Arr.fold LastToFirst (++) ""
--> "evil"

Convert the Arr to an Array. Just do this in the end. Try to keep extra information as long as you can.

Arr.nats nat5
    |> Arr.map val
    |> Arr.toArray
--> Array.fromList [ 0, 1, 2, 3, 4 ]

Combine the elements of 2 Arrs to a new element. If one list is longer, the extra elements are dropped.

teamLifes aBoard bBoard =
    Arr.map2 (\a b -> a.lifes + b.lifes)
        aBoard
        bBoard

Works like map2.

Works like map2.

A fold where the initial result is the first value.

Arr.foldWith FirstToLast maximum
    (Arr.from3 234 345 543)
--> 543

Flip the order of the elements.

Arr.from5 "l" "i" "v" "e"
    |> Arr.reverse
--> Arr.from5 "e" "v" "i" "l"

Set the element at an index in a direction.

Arr.from3 "I" "am" "ok"
    |> Arr.replaceAt nat2 FirstToLast "confusion"
--> Arr.from3 "I" "am" "confusion"


Arr.from3 "I" "am" "ok"
    |> Arr.replaceAt nat1 LastToFirst "feel"
--> Arr.from3 "I" "feel" "ok"

Use a lower minimum length in the type.

[ atLeast3Elements
, atLeast4Elements
]

Elm complains:

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

[ atLeast3Elements
, atLeast4Elements
    |> Arr.lowerMinLength nat3
]

Make an Arr with a fixed maximum length fit into functions with require a higher maximum length.

While designing argument annotations as general as possible:

atMost18Elements : Arr (In min Nat18) ...

The argument in atMost18Elements should also fit in atMost19Elements.

atMost19Elements theArgument
--> error :(


atMost19Elements
    (theArgument |> Arr.restoreMaxLength nat18)
--> works

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

import Serialize




-- we can't start if we have no worlds to choose from!
serializeGameRow :
    Serialize.Codec
        String
        (Arr (Only Nat10) GameField)
serializeGameRow =
    Arr.serialize nat10 serializeGameField


encode : Arr (Only Nat10) GameField -> Bytes
encode =
    Serialize.encodeToBytes serializeGameRow


decode :
    Bytes
    ->
        Result
            (Serialize.Error String)
            (Arr (Only Nat10) GameField)
decode =
    Serialize.decodeFromBytes serializeGameRow