Cap the Nat (ArgIn ...) to at most a number.

between5And15
    |> InNat.atMost nat10 { min = nat5 }
--> : Nat (In Nat5 (Nat10Plus a))

min ensures that that number is at least the minimum.

If the Nat (ArgIn ...) is less than a Nat, return that number instead.

nat5 |> InNat.atLeast nat10
--> Nat 10


nat15 |> InNat.atLeast nat10
--> Nat 15

Is the Nat (ArgIn ...) Greater, Less or Equal than a value?

min ensures that the Nat (ArgN ...) is greater than the minimum.

giveAPresent { age } =
    case
        (age |> Nat.lowerMin nat0)
            |> InNat.is nat18 { min = nat0 }
    of
        Nat.Less age ->
            toy { age = age }


        Nat.Greater age ->
            experience { age = age }


        Nat.Equal () ->
            bigPresent


toy : { age : Nat (ArgIn min Nat17 maybeN) } -> Toy


experience :
    { age : Nat (ArgIn (Nat19Plus orOlder) max maybeN) }
    -> Experience

Compared to a range from a lower to an upper bound, is the Nat (ArgIn ...)

• InRange

• AboveRange: greater than the upper bound or

• BelowRange: less than the lower bound?

min ensures that the lower bound is greater than the minimum.

justIfBetween3And10 nat =
    case
        (nat |> Nat.lowerMin nat0)
            |> InNat.isInRange nat3 nat10 { min = nat0 }
    of
        Nat.InRange ->
            Just


        _ ->
            Nothing


justIfBetween3And10 nat9
--> Just (Nat 9)


justIfBetween3And10 nat123
--> Nothing

Is the Nat (ArgIn ...)

• EqualOrGreater than a lower bound or

• Below?

min ensures that the lower bound is greater than the minimum.

vote : { age : Nat (ArgIn (Nat18Plus orOlder) max maybeN) } -> Vote


tryToVote { age } =
    case
        (age |> Nat.lowerMin nat0)
            |> InNat.isAtLeast nat18 { min = nat0 }
    of
        Nat.Below _ ->
            --😓
            Nothing


        Nat.EqualOrGreater age ->
            Just (vote { age = age })

Is the Nat (ArgIn ...)

• EqualOrLess than an upper bound or

• Above?

min ensures that the upper bound is greater than the minimum.

goToU18Party : { age : Nat (ArgIn min Nat17 maybeN) } -> Snack


tryToGoToU18Party { age } =
    case
        (age |> Nat.lowerMin nat0)
            |> InNat.isAtMost nat17 { min = nat0 }
    of
        Nat.EqualOrLess age ->
            Just (goToU18Party { age = age })


        Nat.Above ->
            Nothing

Add a Nat (ArgN ...).

between70And100
    |> InNat.addN nat7
--> : Nat (In Nat77 (Nat107Plus a))

Subtract an exact Nat (ArgN ...) value.

between7And10
    |> InNat.subN nat7
--> : Nat (In Nat0 (Nat3Plus a))

Add a Nat (ArgIn ...).

between3And10
    |> InNat.add between1And12 nat1 nat12
--> : Nat (In Nat4 (Nat22Plus a))

Subtract a Nat (ArgIn ...).

The 2 following arguments are

• the minimum subtracted value

• the maximum subtracted value

between6And12
    |> InNat.sub between1And5 nat1 nat5
--> : Nat (In Nat1 (Nat5Plus a))

Convert it to a Nat (In min max).

InNat.value nat4
--> : Nat (In Nat4 (Nat4Plus a))

Example

[ in3To10, nat3 ]

Elm complains:

But all the previous elements in the list are: Nat (In Nat3 Nat10)

[ in3To10
, nat3 |> InNat.value
]

A Codec to serialize Nats within a lower & upper bound.

import Serialize


serializePercent :
    Serialize.Codec
        String
        (Nat (In Nat0 (Nat100Plus a)))
serializePercent =
    InNat.serialize nat0 nat100


encode : Nat (ArgIn min Nat100 maybeN) -> Bytes
encode =
    InNat.value
        >> Serialize.encodeToBytes serializePercent


decode :
    Bytes
    ->
        Result
            (Serialize.Error String)
            (Nat (In Nat0 (Nat100Plus a)))
decode =
    Serialize.decodeFromBytes serializePercent

For decoded Ints out of the expected bounds, the Result is an error message.