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

between5And15
    |> InNat.atMost nat10 { min = nat5 }
--> is of type Nat (ValueIn Nat5 (Nat10Plus a))

min ensures that that number is at least the minimum.

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

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


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

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

min ensures that the Nat (N ...) is bigger than the minimum.

present =
    Nat.lowerMin nat0
        >> InNat.is nat18
            { min = nat0 }
            { less = \age -> appropriateToy { age = age }
            , greater = \age -> appropriateExperience { age = age }
            , equal = \() -> bigPresent
            }


appropriateToy : { age : Nat (In min Nat17 maybeN) } -> Toy


appropriateExperience : { age : Nat (In (Nat19Plus orOlder) max maybeN) } -> Experience

Compared to a range first to last, is the Nat (In ...)

• inRange

• greater than the last or

• less than the first?

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

justIfBetween3And10 nat9
--> Just (Nat 9)

justIfBetween3And10 nat123
--> Nothing

Is the Nat (In ...)

• equalOrGreater than a Nat or

• less?

vote : { age : Nat (In (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 (In ...)

• equalOrLess than a Nat or

• greater?

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

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

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

between70And100
    |> InNat.addN nat7
--> is of type Nat (In Nat77 (Nat107Plus a))

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

between7And10
    |> InNat.subN nat7
--> is of type Nat (ValueIn Nat0 (Nat3Plus a))

Use MinNat.subN if the maximum value is not known.

Add a Nat (In ...).

between3And10
    |> InNat.add between1And12 nat1 nat12
--> is of type Nat (ValueIn Nat4 (Nat22Plus a))

Subtract a Nat (In ...).

The 2 following arguments are

• the minimum subtracted value

• the maximum subtracted value

between6And12
    |> InNat.sub between1And5 nat1 nat5
--> is of type Nat (ValueIn Nat1 (Nat5Plus a))

Convert it to a Nat (ValueIn min max).

nat4 |> InNat.value
--> is of type Nat (ValueIn Nat4 (Nat4Plus a))

Example

[ in3To10, nat3 ]

Elm complains:

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

[ in3To10
, nat3 |> InNat.value
]

A Codec to serialize Nats with a lower limit.

import Serialize


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


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


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

For decoded Ints lower than minimum expected value, the Result is an error message.