An Array that knows about the amount of elements it holds

result type

-- amount >= 5
: ArraySized (Min (Up5 x_)) ...


-- 2 <= amount <= 12
: ArraySized
:     (In (Up2 minX_) (Up12 maxX_)) ...

Representing a result's numbers as this weird Up<n> x is what allows the little magic tricks in the library: glueing, taking, dropping, chunking, comparing, ...

argument type

-- = 15
: ArraySized (Exactly N15) ...


-- amount >= 4
: ArraySized (In (Fixed (Add4 minMinus4_)) max_) ...


-- 4 <= amount <= 15
: ArraySized
:     (In (Fixed (Add4 minMinus4_)) (Up maxTo15_ To N15)) ...

to allow the broadest range of desired lengths,

• to require nothing about the upper limit → leave the maximum as a variable
• fix lower limits to the desired minimum number + some variable
• require the actual upper limit to go Up a variable amount to arrive at the desired maximum number

stored type

in your Model for example. They look just like result types but every Up<n> x becomes Fixed N<n>, avoiding type variables

-- amount >= 4
: ArraySized (Min (Fixed N4)) ...


-- 4 <= amount <= 15
: ArraySized (InFixed N4 N15) ...


-- = 15
: ArraySized (Exactly N15) ...

InFixed min max being a shorthand for

In (Fixed min) (Fixed max)

Exactly n being a shorthand for

InFixed n n

== on ranges crashes elm. Use safe comparison methods or convert toValue

A given amount of same elements

import N exposing (n4)


ArraySized.repeat 'L' n4
--: ArraySized
--:     (In (Up4 minX_) (Up4 maxX_))
--:     Char
    |> ArraySized.toList
--> [ 'L', 'L', 'L', 'L' ]


ArraySized.repeat 'L' atLeast3
--: ArraySized (Min (Up3 x_)) Char

Random.Generator for a given amount of random elements

import N exposing (n5)


ArraySized.random (Random.float 0 1) n5
--: Random.Generator
--:     (ArraySized
--:         (In (Up5 minX_) (Up5 maxX_))
--:         Float
--:     )

Pairs really well with

N.randomIn ( <length min>, <length max> )
    |> Random.andThen
        (ArraySized.random <element>)

Increasing natural numbers until including a given number

import N exposing (n3)


ArraySized.upTo n3
--: ArraySized
--:     (In (Fixed N4) (Up4 maxX_))
--:     (N (In (Up0 minX_) (Up3 maxX_)))
    |> ArraySized.map N.toInt
    |> ArraySized.toList
--> [ 0, 1, 2, 3 ]


ArraySized.upTo between2And9
    |> ArraySized.map (N.add n3)
--: ArraySized
--:    (In (Fixed N3) (Up10 maxX_))
--:    (N (In (Up5 minX_) (Up12 maxX_)))

minTo is helpful to turn the Fixed length minimum into a difference if you need that (for results etc.)

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

arrayFromSomeOtherLibrary |> ArraySized.fromArray
--: ArraySized (Min (Up0 x_))

Don't use it for construction:

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

Make sure the compiler knows as much as you about the amount of elements!

ArraySized.l7 0 1 2 3 4 5 6 -- ok


ArraySized.upTo n6 -- big yes

"wrap early, unwrap late"

Create from a List. As every List has >= 0 elements:

listFromSomeOtherLibrary |> ArraySized.fromList
--: ArraySized (Min (Up0 x_))

Don't use for construction:

ArraySized.fromList [ 0, 1, 2, 3, 4, 5, 6 ]
-- big no!

Make sure the compiler knows as much as you about the amount of elements!

ArraySized.l7 0 1 2 3 4 5 6 -- ok


ArraySized.upTo n6 -- big yes

"wrap early, unwrap late"

On Just ArraySized.l1, on Nothing empty

import N exposing (n0)
import Emptiable exposing (filled)


filled "hi"
    |> ArraySized.fromEmptiable
    --: ArraySized
    --:     (In (Up0 minX_) (Up1 maxX_))
    |> ArraySized.toList
--> [ "hi" ]


Emptiable.empty
    |> ArraySized.fromEmptiable
    --: ArraySized
    --:     (In (Up0 minX_) (Up1 maxX_))
    |> ArraySized.toList
--> []

Sadly, they way natural number constraints are defined, possiblyOrNever can't be transferred

Create from a Stack. As every Stack has >= 0 elements:

listFromSomeOtherLibrary |> ArraySized.fromStackFilled
--: ArraySized (Min (Up1 x_))

Don't use for construction:

ArraySized.fromStackFilled
    (Stack.topDown 0 [ 1, 2, 3, 4, 5, 6 ])
-- big no!

Make sure the compiler knows as much as you about the amount of elements!

ArraySized.l7 0 1 2 3 4 5 6 -- ok


ArraySized.upTo n6 -- big yes

"wrap early, unwrap late"

Only have an Emptiable (Stacked ...) Possibly? → fromStackEmptiable

Create from a Stack. As every Stack has >= 0 elements:

listFromSomeOtherLibrary |> ArraySized.fromStackEmptiable
--: ArraySized (Min (Up0 x_))

Don't use for construction:

ArraySized.fromStackEmptiable
    (Stack.fromList [ 0, 1, 2, 3, 4, 5, 6 ])
-- big no!

Make sure the compiler knows as much as you about the amount of elements!

ArraySized.l7 0 1 2 3 4 5 6 -- ok


ArraySized.upTo n6 -- big yes

"wrap early, unwrap late"

Have an Emptiable (Stacked ...) Never? → fromStackFilled

Create from a String. As every String has >= 0 elements:

stringFromSomeOtherLibrary |> ArraySized.fromString
--: ArraySized (Min (Up0 x_)) Char

Try not to use this for construction and instead use the safe versions like l<n>

No elements

ArraySized.empty
--: ArraySized (In (Up0 minX_) (Up0 maxX_)) element_
    |> ArraySized.push ":)"
    --: ArraySized
    --:     (In (Up1 minX_) (Up1 maxX_))
    --:     String

Create with only 1 single given element

Create with 2 given elements in the order they are supplied

Create with 3 given elements in the order they are supplied

Create with 4 given elements in the order they are supplied

Create with 5 given elements in the order they are supplied

Create with 6 given elements in the order they are supplied

Create with 7 given elements in the order they are supplied

Create with 8 given elements in the order they are supplied

Create with 9 given elements in the order they are supplied

Create with 10 given elements in the order they are supplied

Create with 11 given elements in the order they are supplied

Create with 12 given elements in the order they are supplied

Create with 13 given elements in the order they are supplied

Create with 14 given elements in the order they are supplied

Create with 15 given elements in the order they are supplied

Create with 16 given elements in the order they are supplied

Its amount of elements

import N exposing (n3)


ArraySized.l3 1 2 3
    |> ArraySized.length
    --: N (In (Up3 minX_) (Up3 maxX_))
    |> N.toInt
--> 3


between3And5Elements |> ArraySized.length
--: N (In (Up3 minX_) (Up5 maxX_))


atLeast3Elements |> ArraySized.length
--: N (Min (Up3 minX_))

Its element at a valid location in a given Direction

import Linear exposing (Direction(..))
import N exposing (n1)


ArraySized.l4 0 1 2 3
    |> ArraySized.element ( Up, n1 )
--> 1


ArraySized.l4 0 1 2 3
    |> ArraySized.element ( Down, n1 )
--> 2

Its possible element at a location in a given Direction. Because the index doesn't promise it's <= the ArraySized's length minimum, elementTry gives back a Result

import Linear exposing (Direction(..))
import N exposing (n1, n5)


ArraySized.l4 0 1 2 3
    |> ArraySized.elementTry ( Up, n5 )
--> Err { indexBeyondElements = () }


ArraySized.l4 0 1 2 3
    |> ArraySized.elementTry ( Down, n1 )
--> Ok 2

Its only value

ArraySized.l1 "hi" |> ArraySized.to1
--> "hi"

Whether all elements satisfy a given test

ArraySized.l2 2 3 |> ArraySized.all (\n -> n <= 4)
--> True


ArraySized.l2 2 7 |> ArraySized.all (\n -> n <= 4)
--> False


ArraySized.empty |> ArraySized.all (\n -> n <= 4)
--> True

Whether at least one element satisfies a given test

ArraySized.l2 300 -5 |> ArraySized.any (\n -> n <= 4)
--> True


ArraySized.l2 5 5 |> ArraySized.any (\n -> n <= 4)
--> False


ArraySized.empty |> ArraySized.any (\n -> n <= 4)
--> False

Set the element at an index in a given Direction

import Linear exposing (Direction(..))
import N exposing (n1, n2)


ArraySized.l3 "I" "am" "ok"
    |> ArraySized.elementReplace ( Up, n2 )
        (\() -> "confusion")
    |> ArraySized.toList
--> [ "I", "am", "confusion" ]


ArraySized.l3 "I" "am" "ok"
    |> ArraySized.elementReplace ( Down, n1 )
        (\() -> "feel")
    |> ArraySized.toList
--> [ "I", "feel", "ok" ]

An index that's too high to point to an existing element is ignored and no element is replaced

import Linear exposing (Direction(..))
import N exposing (n3)


ArraySized.l3 "I" "am" "ok"
    |> ArraySized.elementReplace ( Down, n3 )
        (\() -> "feel")
    |> ArraySized.toList
--> [ "I", "am", "ok" ]

Change the element at an index in a given Direction based on its previous value

import Linear exposing (Direction(..))
import N exposing (n0)


ArraySized.l3 1 20 30
    |> ArraySized.elementAlter ( Up, n0 ) (\x -> x * 10)
    |> ArraySized.toList
--> [ 10, 20, 30 ]


ArraySized.l3 1 20 30
    |> ArraySized.elementAlter ( Down, n0 ) negate
    |> ArraySized.toList
--> [ 1, 20, -30 ]

An index that's too high to point to an existing element is ignored and no element is altered

import Linear exposing (Direction(..))
import N exposing (n3)


ArraySized.l3 1 20 30
    |> ArraySized.elementAlter ( Up, n3 ) (\x -> x * 10)
    |> ArraySized.toList
--> [ 1, 20, 30 ]

Flip the order of the elements

ArraySized.l4 "l" "i" "v" "e"
    |> ArraySized.reverse
    |> ArraySized.toList
--> [ "e", "v", "i", "l" ]

Put a new element after all the others

between5And10Elements
    |> ArraySized.push "becomes the last"
--: ArraySized
--:     (In (Up6 minX_) (Up11 maxX_))
--:     String

pushMin if you don't know the length maximum

Put a new element after all the others

atLeast5Elements
    |> ArraySized.pushMin "becomes the last"
--: ArraySized (Min (Up6 minX_)) String

push if you know the length maximum

Put an element in the ArraySized at a given index in a given Direction

import Linear exposing (Direction(..))
import N exposing (n1, n2)


ArraySized.l3 'a' 'c' 'd'
    |> ArraySized.insert ( Up, n1 ) 'b'
    --: ArraySized
    --:     (In (Fixed N4) (Up4 maxX_))
    --:     Char
    |> ArraySized.toList
--> [ 'a', 'b', 'c', 'd' ]


ArraySized.l3 'a' 'c' 'd'
    |> ArraySized.insert ( Down, n2 ) 'b'
    |> ArraySized.toList
--> [ 'a', 'b', 'c', 'd' ]

insertMin if you don't know the length maximum

Need the length minimum to not become Fixed (for results etc.) → |> minTo

Put a new element at an index in a given Direction

import Linear exposing (Direction(..))
import N exposing (n0, n1)


atLeast5Elements
    |> ArraySized.insertMin ( Down, n1 ) "before last"
    --: ArraySized (Min (Fixed N6)) String


minCons :
    element
    -> ArraySized (In (Fixed min) max_) element
    -> ArraySized (Min (Fixed (Add1 min))) element
minCons =
    ArraySized.insertMin ( Up, n0 )

insert if you know the length maximum

Need the length minimum to not become Fixed (for results etc.) → |> minTo

Kick out the element at a given index in a given Direction

import Linear exposing (Direction(..))
import N exposing (n0)


removeLast between1And10Elements =
    between1And10Elements
        |> ArraySized.elementRemove ( Down, n0 )

Don't know the length maximum? → elementRemoveMin

Kick out the element at an index in a given Direction

removeLast =
    TypeSized.elementRemoveMin ( Down, n0 )

Know the length maximum? → elementRemoveMin

Take every filled value, drop every empty

import Emptiable exposing (filled)


ArraySized.l3 (filled "This") Emptiable.empty (filled "fine")
    |> ArraySized.fills
    --: ArraySized
    --:     (In (Up0 minX_) (Up3 maxX_))
    --:     String
    |> ArraySized.toList
--> [ "This", "fine" ]

map |> fills to get the same functionality as "filterMap"

import Emptiable


ArraySized.l3 "1.2" "2" "hello"
    |> ArraySized.map (String.toInt >> Emptiable.fromMaybe)
    |> ArraySized.fills
    |> ArraySized.toList
--> [ 2 ]

If every Emptiable is filled, all of the values. If any element is empty, empty

import Emptiable exposing (filled, fillMap)


ArraySized.empty
    |> ArraySized.allFill
    |> fillMap ArraySized.toList
--> filled []


ArraySized.l3 (filled 1) (filled 2) (filled 3)
    |> ArraySized.allFill
    |> fillMap ArraySized.toList
--> filled [ 1, 2, 3 ]


ArraySized.l3 (filled 1) Emptiable.empty (filled 3)
    |> ArraySized.allFill
--> Emptiable.empty

Funnily, this can sometimes even be nicer than mapN/andMap

groupCall =
    ArraySized.l5 aUser bUser cUser dUser eUser
        |> ArraySized.map .phoneNumber
        |> ArraySized.allFill


-- vs
groupCall =
    map5 ArraySized.l5
        aUser.phoneNumber
        bUser.phoneNumber
        cUser.phoneNumber
        dUser.phoneNumber
        eUser.phoneNumber

A given number of elements to a given direction

It's easy if the minimum to take and the ArraySized's minimum length match

import Linear exposing (Direction(..))
import N exposing (n7)


-- its three last elements
ArraySized.upTo n3AtLeast
    |> ArraySized.take ( Down, n3 )

If the amount taken is greater than the ArraySized's length minimum, add |> N.minTo currentLengthMinimum

-- its first four elements
ArraySized.upTo between3And6
    |> ArraySized.take ( Down, n4 |> N.minTo n3 )

If the amount taken is less than the ArraySized's length minimum, add |> ArraySized.minTo takenMinimum

ArraySized.l8 0 1 2 3 4 5 6 7
    |> ArraySized.minTo n7
    |> ArraySized.take ( Up, n7 )
    --: ArraySized
    --:     (In (Up7 minX_) (Up7 maxX_))
    --:     number_
    |> ArraySized.toList
--> [ 0, 1, 2, 3, 4, 5, 6 ]


ArraySized.l8 0 1 2 3 4 5 6 7
    |> ArraySized.minTo n7
    |> ArraySized.take ( Up, n7AtLeast )
--: ArraySized (Min (Up7 x_)) number_


ArraySized.l8 0 1 2 3 4 5 6 7
    |> ArraySized.minTo n2
    |> ArraySized.take ( Up, between2And7 )
--: ArraySized
--:     (In (Up2 minX_) (Up7 maxX_))
--:     number_

Elements after a certain number of elements in a given Direction

import Linear exposing (Direction(..))
import N exposing (n2)


ArraySized.l4 0 1 2 3
    |> ArraySized.drop ( Down, n2 )
    --: ArraySized
    --:     (In (Up2 minX_) (Up2 maxX_))
    --:     number_
    |> ArraySized.toList
--> [ 0, 1 ]


between6And10Elements
    |> ArraySized.drop ( Up, between2And3 )
    --: ArraySized
    --:     (In (Up3 minX_) (Up8 maxX_))
    --:     number_

• Don't know its length maximum? → dropMin
• Can the dropped length's maximum be greater than its length's minimum? → dropOverMin

Elements after a certain number of elements in a given Direction

import Linear exposing (Direction(..))
import N exposing (n2)


atLeast6Elements
    |> ArraySized.dropMin ( Down, n2 )
--: ArraySized (Min (Fixed N4)) ...

Know its length maximum? → drop

drop a given length that can be greater than the ArraySized's length maximum

import Linear exposing (Direction(..))
import N exposing (n2)


between3And6Elements
    |> ArraySized.dropOverMin ( Down, n5 )
--: ArraySized (In (Up0 minX_) (Fixed N1)) ...

Split the ArraySized into equal-sized (except remainder) slices in a given Direction

• chunks: the ArraySized divided into equal-sized Arrs
• remainder: values to one side that don't fill a whole group

↓

import Linear exposing (Direction(..))
import N exposing (n0, n5)


ArraySized.l7 1 2 3 4 5 6 7
    |> ArraySized.toChunksOf Up n5
    --: { chunks :
    --:     ArraySized
    --:         (In (Up0 minX_) (Up7 maxX_))
    --:         (ArraySized
    --:             (In (Up5 chunkMinX_) (Up5 chunkMaxX))
    --:             number_
    --:         )
    --: , remainder :
    --:     ArraySized
    --:         (In
    --:             (Up0 remainderMinX_)
    --:             (Up4 chunkMaxX)
    --:         )
    --:         number_
    --: }
    |> .remainder
    |> ArraySized.toList
--> [ 6, 7 ]




ArraySized.l7 1 2 3 4 5 6 7
    |> ArraySized.toChunksOf Down n5
    |> .remainder
    |> ArraySized.toList
--> [ 1, 2 ]

Combine each element with an element at the same index from a given ArraySized into a tuple

Every element beyond the minimum length of both is't part of the final ArraySized

import ArraySized


answer
    |> ArraySized.and guess
    |> ArraySized.map
        (\( answerChar, guessChar ) ->
            { directMatch = guessChar == answerChar }
        )

This is often misused:

• multiple structures for different attributes of the same thing
  • example: one list for exercises, one matching the cards' indexes with progress
  • these should be in the same structure
• applying multiple changes for a sequence of indexes
  • example: https://github.com/Rototu/storefront/blob/f8fe0b7cb823e3a50f175985a13762f9482ae4a8/frontend/src/Page/Home.elm#L24-L32
  • each of those indices seem to have special meaning. Use a record to gain type-safety and be more descriptive
• stupid stuff where another operation like map would be more appropriate
  • example: https://github.com/dclutr/a-toastmasters-certificates-tool/blob/0cb97c2766c6c51bb32881a1e7c77beb21b1c32a/Main.elm#L165-L172

Attach elements of an ArraySized with an exact amount of elements to a given direction

import Linear exposing (Direction(..))


ArraySized.l3 1 2 3
    |> ArraySized.glue Up (ArraySized.l3 4 5 6)
    --: ArraySized
    --:     (In (Up6 minX_) (Up6 maxX_))
    --:     number_
    |> ArraySized.toList
--> [ 1, 2, 3, 4, 5, 6 ]


ArraySized.l3 1 2 3
    |> ArraySized.glue Down (ArraySized.l3 4 5 6)
    |> ArraySized.toList
--> [ 4, 5, 6, 1, 2, 3 ]

Don't know both length maxima? → glueMin

Attach elements of an ArraySized to the end in a given direction

ArraySized.l3 1 2 3
    |> ArraySized.glueMin Up atLeast3Elements
--: ArraySized (Min (Up6 x_)) ...


ArraySized.l3 1 2 3
    |> ArraySized.glueMin Down atLeast3Elements
--: ArraySized (Min (Up6 x_)) ...

Know both length maxima? → glue

Pad in a given Direction with a given ArraySized to reach a given length

import N exposing (n8)
import Linear exposing (Direction(..))


type Bit
    = I
    | O


ArraySized.l3 I O I
    |> ArraySized.padToLength Down (ArraySized.repeat O) n8
    --: ArraySized (In (Fixed N8) (Up8 x_))
    |> ArraySized.toList
--> [ O, O, O, O, O, I, O, I ]


ArraySized.l4
    (ArraySized.l3 I I I |> ArraySized.maxTo n8)
    (ArraySized.l8 O I I I O I O O)
    (ArraySized.l8 O I I I O I O O)
    (ArraySized.l8 O I I I O I O O)
    |> ArraySized.map
        (ArraySized.padToLength Down (ArraySized.repeat O) n8)
    |> ArraySized.map ArraySized.toList
    |> ArraySized.toList
--> [ [ O, O, O, O, O, I, I, I ]
--> , [ O, I, I, I, O, I, O, O ]
--> , [ O, I, I, I, O, I, O, O ]
--> , [ O, I, I, I, O, I, O, O ]
--> ]

Place all elements of an ArraySized between all current members. Extra elements of either ArraySized are glued to the end without separating elements from the other ArraySized

import N exposing (n2)


ArraySized.l3 "turtles" "turtles" "turtles"
    |> ArraySized.interweave (ArraySized.repeat "on" n2)
    --: ArraySized
    --:     (In (Up5 minX_) (Up5 maxX_))
    --:     String
    |> ArraySized.toList
--> [ "turtles", "on", "turtles", "on", "turtles" ]


ArraySized.l3 "turtles" "turtles" "turtles"
    |> ArraySized.interweave (ArraySized.repeat "on" between5And10)
--→ "turtles" "on" "turtles" "on" "turtles" "on" "on" "on" ...
--: ArraySized
--:     (In (Up5 minX_) (Up13 maxX_))
--:     String

Don't know both maxima → interweaveMin

Place all elements of an ArraySized between all current members. Extra elements of either ArraySized are glued to the end without separating elements from the other ArraySized

import N exposing (n2)


ArraySized.l3 "turtles" "turtles" "turtles"
    |> ArraySized.interweaveMin (ArraySized.repeat "on" atLeast2)
    --: ArraySized (Min (Up5 minX_)) String

Know both maxima → interweave

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

import N exposing (n10, n16)


chooseFormation :
    ArraySized (In minLength_ N50) Character
    -> Formation
chooseFormation characters =
    case characters |> ArraySized.hasIn ( n10, n16 ) of
        Ok between10And16 ->
            SpecialAttack between10And16


        Err (N.Below n9AtMost) ->
            Retreat n9AtMost


        Err (N.Above n17AtLeast) ->
            Fight n17AtLeast

Compare its length to a given exact length. Does it match or is it BelowOrAbove?

import N exposing (n7)


chooseFormation :
    ArraySized (In min N50) Character
    -> Formation
chooseFormation characters =
    case characters |> ArraySized.has n7 of
        Ok exactly7 ->
            SpecialAttack exactly7


        Err (N.Below l6AtLeast) ->
            Retreat l6AtLeast


        Err (N.Above l8AtLeast) ->
            Fight l8AtLeast

Is its length below (Err) or at least as big as (Ok) a given N?

import N exposing (n5)


atLeast5 :
    ArraySized (In minLength_ max) element
    -> Maybe (ArraySized (In (Up5 minX_) max) element)
atLeast5 =
    ArraySized.hasAtLeast n5
        >> Result.toMaybe

Is its length atMost (Ok) or above (Err) a given length?

-- at least 3 and only up to 50 tags
tag :
    ArraySized (In (Add3 minMinus3_) (Up maxTo50_ To N50)) String
    -> (Metadata -> MetadataTagged)


tagIfValidTags :
    ArraySized (In (Add3 minMinus3_) max_)
    -> Metadata
    -> Maybe MetadataTagged
tagIfValidTags tags =
    case tags |> ArraySized.hasAtMost n50 of
        Ok atMost50 ->
            tag atMost50 >> Just


        Err _ ->
            \_ -> Nothing

Change all elements based on their current values

import N exposing (n25)


aToZ : ArraySized (In N26 (N26Plus a_)) Char
aToZ =
    ArraySized.upTo n25
        |> ArraySized.map inABC


inABC index =
    ('a' |> Char.toCode)
        + (index |> N.toInt)
        |> Char.fromCode

Oh look, more type-safety!

Reduce an ArraySized in a given Direction

import Linear exposing (Direction(..))


ArraySized.l4 'l' 'i' 'v' 'e'
    |> ArraySized.foldFrom "" Down String.cons
--> "live"


ArraySized.l4 'l' 'i' 'v' 'e'
    |> ArraySized.foldFrom "" Up String.cons
--> "evil"


sum =
    ArraySized.foldFrom 0 Up (\soFar n -> soFar + n)


product =
    ArraySized.foldFrom 0 Up (\soFar n -> soFar * n)

A fold in a given Direction where the initial result is the first element in the ArraySized

import Linear exposing (Direction(..))


ArraySized.l3 234 345 543
    |> ArraySized.fold Up Basics.max
--> 543


ArraySized.l3 "go" "to" "uni"
    |> ArraySized.fold Down
        (\word soFar -> soFar ++ " " ++ word)
--> "uni to go"

Convert to an Array.

Make these kinds of conversions your final step. Try to keep extra information as long as you can: "wrap early, unwrap late"

import N exposing (n4)
import Array


ArraySized.upTo n4
    |> ArraySized.map N.toInt
    |> ArraySized.toArray
--> Array.fromList [ 0, 1, 2, 3, 4 ]

Convert to a List.

Make these kinds of conversions your final step. Try to keep extra information as long as you can: "wrap early, unwrap late"

import N exposing (n4)


ArraySized.upTo n4
    |> ArraySized.map N.toInt
    |> ArraySized.toList
--> [ 0, 1, 2, 3, 4 ]

On empty Nothing, on l1 Just it's only value

Sadly, they way natural number constraints are defined, emptiness type information can't be transferred

Convert to an Emptiable (Stacked ...) Possibly.

Make these kinds of conversions your final step. Try to keep extra information as long as you can: "wrap early, unwrap late"

import N exposing (n4)
import Emptiable
import Stack


ArraySized.l4 (0 |> Emptiable.filled) Emptiable.empty Emptiable.empty (3 |> Emptiable.filled)
    |> ArraySized.fills
    |> ArraySized.toStackEmptiable
--> Stack.topDown 0 [ 3 ]
--: Emptiable (Stacked Int) Possibly

Have >= 1 element? → Keep an Emptiable ... never_ toStackFilled

Convert to an Emptiable (Stacked ...) never_.

Make these kinds of conversions your final step. Try to keep extra information as long as you can: "wrap early, unwrap late"

import N exposing (n4)
import Stack


ArraySized.upTo n4
    |> ArraySized.map N.toInt
    |> ArraySized.toStackFilled
--> Stack.topDown 0 [ 1, 2, 3, 4 ]
--: Emptiable (Stacked Int) Never

Don't have >= 1 element? → toStackEmptiable

Convert to a String.

Make these kinds of conversions your final step. Try to keep extra information as long as you can: "wrap early, unwrap late"

import N exposing (n4)


ArraySized.upTo n4
    |> ArraySized.map
        (\n ->
            ('a' |> Char.toCode)
                + (n |> N.toInt)
                |> Char.fromCode
        )
    |> ArraySized.toString
--> "abcde"

Transform the ArraySized into a Toop.T2. This makes accessing elements and pattern matching easier.

Transform the ArraySized into a Toop.T3. This makes accessing elements and pattern matching easier.

Transform the ArraySized into a Toop.T4. This makes accessing elements and pattern matching easier.

Transform the ArraySized into a Toop.T5. This makes accessing elements and pattern matching easier.

Transform the ArraySized into a Toop.T6. This makes accessing elements and pattern matching easier.

Transform the ArraySized into a Toop.T7. This makes accessing elements and pattern matching easier.

Transform the ArraySized into a Toop.T8. This makes accessing elements and pattern matching easier.

Transform the ArraySized into a Toop.T9. This makes accessing elements and pattern matching easier.

Transform the ArraySized into a Toop.T10. This makes accessing elements and pattern matching easier.

Transform the ArraySized into a Toop.T11. This makes accessing elements and pattern matching easier.

Transform the ArraySized into a Toop.T12. This makes accessing elements and pattern matching easier.

Transform the ArraySized into a Toop.T13. This makes accessing elements and pattern matching easier.

Transform the ArraySized into a Toop.T14. This makes accessing elements and pattern matching easier.

Transform the ArraySized into a Toop.T15. This makes accessing elements and pattern matching easier.

Transform the ArraySized into a Toop.T16. This makes accessing elements and pattern matching easier.

ArraySized with a length of Fixed range → equatable Value range

ArraySized with a length of equatable Value range → Fixed range, allowing it to be altered, compared, ...

ArraySized with a length with a Fixed minimum → equatable Value minimum

ArraySized with a length with an equatable Value minimum → Fixed minimum, allowing it to be altered, compared, ...

ArraySized with a length with a Fixed maximum → equatable Value maximum

ArraySized with a length with an equatable Value maximum → Fixed maximum, allowing it to be altered, compared, ...

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

type alias Row =
    ArraySized (Exactly N18) Field

Row's length range can't be added to another length

glue2TemporaryFields : Row -> ...
glue2TemporaryFields rowFromModelOrSomeStorage =
    ArraySized.repeat Temporary n2
        |> ArraySized.glue Up rowFromModelOrSomeStorage

Only Up<n> x can do that:

glue2TemporaryFields :
    Row
    ->
        ArraySized
            (In (Up20 minX_) (Up20 maxX_))
            Field
glue2TemporaryFields rowFromModelOrSomeStorage =
    ArraySized.repeat Temporary n2
        |> ArraySized.glue Up
            (rowFromModelOrSomeStorage
                |> ArraySized.minTo n18
                |> ArraySized.maxTo n18
            )

Have a specific minimum in mind? → minTo

Want to increase the upper bound by a fixed amount? ↓

ArraySized.l4 'a' 'b' 'c' 'd'
    --: ArraySIzed (In (Up4 minX_) (Up4 maxX_))
    |> ArraySized.minDown n2
--: ArraySIzed (In (Up2 minX_) (Up4 maxX_))

When is this useful? Very rarely, to preserve type variables

emptiablePush :
    Emptiable element possiblyOrNever_
    ->
        (ArraySized
            (In
                (Up minX To minPlusX)
                (Up maxX To maxPlusX)
            )
            element
         ->
            ArraySized
                (In (Up minX To minPlusX) (Up maxX To (Add1 maxPlusX)))
                element
        )
emptiablePush emptiableElementToPush =
    case emptiableElementToPush of
        Emptiable.Empty _ ->
            ArraySized.maxUp n1


        Emptiable.Filled elementToPush ->
            ArraySized.push elementToPush
                >> ArraySized.minDown n1

More in N.minDown

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

type alias Row =
    ArraySized (Exactly N18) Field

Row's length range can't be added to another length

glue2TemporaryFields : Row -> ...
glue2TemporaryFields rowFromModelOrSomeStorage =
    ArraySized.repeat Temporary n2
        |> ArraySized.glue Up rowFromModelOrSomeStorage

Only Up<n> x can do that:

glue2TemporaryFields :
    Row
    ->
        ArraySized
            (In (Up20 minX_) (Up20 maxX_))
            Field
glue2TemporaryFields rowFromModelOrSomeStorage =
    ArraySized.repeat Temporary n2
        |> ArraySized.glue Up
            (rowFromModelOrSomeStorage
                |> ArraySized.minTo n18
                |> ArraySized.maxTo n18
            )

Another example: re-enabling an argument's maximum difference

atMost18Elements : ArraySized (In min_ (Up maxTo18_ To N18)) ...

The argument in atMost18Elements should also fit in atMost19Elements for example

atMost19Elements theArgument -- error


atMost19Elements (theArgument |> ArraySized.maxTo n19)

maxUp n1 is also possible, but unless you want to preserve the maxTo18_ type variable, there's no need to not use this absolute operation

Convert the ArraySized (In min ...) to a ArraySized (Min min)

between4And10Elements |> ArraySized.maxToInfinity
--: ArraySized (Min N4) ...

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 ArraySized (Min N1) ...

[ atLeast1Element
, between1And10Elements |> ArraySized.maxToInfinity
]

Have a specific maximum in mind? → maxTo

Want to increase the upper bound by a fixed amount? ↓

ArraySized.l4 'a' 'b' 'c' 'd'
    --: ArraySIzed (In (Up4 minX_) (Up4 maxX_))
    |> ArraySized.maxUp n2
--: ArraySIzed (In (Up4 minX_) (Up6 maxX_))

When is this useful? Very rarely, to preserve type variables

emptiablePush :
    Emptiable element possiblyOrNever_
    ->
        (ArraySized
            (In
                (Up minX To minPlusX)
                (Up maxX To maxPlusX)
            )
            element
         ->
            ArraySized
                (In (Up minX To minPlusX) (Up maxX To (Add1 maxPlusX)))
                element
        )
emptiablePush emptiableElementToPush =
    case emptiableElementToPush of
        Emptiable.Empty _ ->
            ArraySized.maxUp n1


        Emptiable.Filled elementToPush ->
            ArraySized.push elementToPush
                >> ArraySized.minDown n1

More in N.maxUp