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

Compare the Nat (ArgIn ...) to an exact Nat (ArgN ...). Is it greater, less or equal?

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

present =
    Nat.lowerMin nat0
        >> InNat.is nat18
            { min = nat0 }
            { less = \age -> toy { age = age }
            , greater = \age -> experience { age = age }
            , 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

• greater than the upper bound or

• less than the lower bound?

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

justIfBetween3And10 =
    Nat.lowerMin nat0
        >> InNat.isInRange nat3 nat10
            { min = nat0 }
            { less = \_ -> Nothing
            , greater = \_ -> Nothing
            , inRange = Just
            }


justIfBetween3And10 nat9
--> Just (Nat 9)


justIfBetween3And10 nat123
--> Nothing

Is the Nat (ArgIn ...)

• equalOrGreater than a lower bound or

• less?

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

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


tryToVote =
    Nat.lowerMin nat0
        >> InNat.isAtLeast nat18
            { min = nat0 }
            { less = Nothing --😓
            , equalOrGreater = \age -> Just (vote { age = age })
            }

Is the Nat (ArgIn ...)

• equalOrLess than an upper bound or

• greater?

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

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


tryToGoToU18Party =
    Nat.lowerMin nat0
        >> InNat.isAtMost nat17
            { min = nat0 }
            { equalOrLess =
                \age -> Just (goToU18Party { age = age })
            , greater = Nothing
            }

Add a fixed Nat (ArgN ...) value.

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).

nat4 |> InNat.value
--> : 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.