A Nat (In ...) from an Int, clamped between a minimum & maximum.

• if the Int < minimum, minimum is returned
• if the Int > maximum, maximum is returned

clampBetween3And12 =
    Nat.In.intInRange (nat3 |> Nat.N.toIn) (nat12 |> Nat.N.toIn)

9 |> clampBetween3And12 --> Nat 9

0 |> clampBetween3And12 --> Nat 3

99 |> clampBetween3And12 --> Nat 12

If you want to handle the cases < minimum & > maximum explicitly, use isIntInRange.

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

nat5 |> Nat.N.toIn
    |> Nat.In.atLeast nat10
--> Nat 10


nat15 |> Nat.N.toIn
    |> Nat.In.atLeast (nat10 |> Nat.N.toIn)
--> Nat 15

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

nat5 |> Nat.N.toIn
    |> Nat.In.atMost nat10 { min = nat5 }
--> Nat.In 5


nat15 |> Nat.N.toIn
    |> Nat.In.lowerMin (nat5 |> Nat.N.toIn)
    |> Nat.In.atMost nat10 { min = nat5 }
--> Nat 10

min ensures that that number is at least the minimum.

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

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

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


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


appropriateExperience : { age : Nat (In Nat19 max) } -> Experience

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

• inRange

• greater than the last or

• less than the first?

justIfBetween3And10 =
    Nat.In.lowerMin (nat0 |> Nat.N.toIn)
        >> Nat.In.isInRange { first = nat3, last = nat10 }
            { min = nat0 }
            { less = \_ -> Nothing
            , greater = \_ -> Nothing
            , inRange = Just
            }

justIfBetween3And10 (nat9 |> Nat.N.toIn)
--> Just (Nat 9)

justIfBetween3And10 (nat123 |> Nat.N.toIn)
--> Nothing

An Int compared to a range from first to last.

rejectOrAcceptUserInt =
    isIntInRange (nat1 |> Nat.N.toIn) (nat100 |> Nat.N.toIn)
        { less = Err "must be >= 1"
        , greater = \_-> Err "must be <= 100"
        , inRange = Ok
        }


rejectOrAcceptUserInt (Nat.N.toIn nat0)
--> Err "must be >= 1"

Is the Nat (In ...)

• equalOrGreater than a Nat or

• less?

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

tryToVote =
    Nat.In.lowerMin (nat0 |> Nat.N.toIn)
        >> Nat.In.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) } -> List Snack

tryToGoToU18Party =
    Nat.In.lowerMin (nat0 |> Nat.N.toIn)
        >> Nat.In.isAtMost nat17
            { min = nat0 }
            { equalOrLess = \age -> Just (goToU18Party { age 0 age })
            , greater = Nothing
            }

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

nat70 |> Nat.N.toIn
    |> Nat.In.addN nat7
--> is of type Nat (In Nat77 (Nat77Plus a))

Subtract a fixed Nat value.

nat7 |> Nat.N.toIn
    |> Nat.In.subN nat7
--> is of type Nat (In Nat0 a)

Add a Nat (In ...).

Nat.N.toIn nat3
    |> Nat.In.add between1And12 nat1 nat12
--> of type Nat (In Nat4 (Nat15Plus a))

Subtract a Nat (In ...).

The 2 following arguments are

• the minimum subtracted value
• the maximum subtracted value

If you don't have both at hand, use subLossy.

nat6 |> Nat.N.toIn
    |> Nat.In.sub between1And5 nat1 nat5
--> is of type Nat (In Nat1 (Nat5Plus a))

Divide (//) by a Nat (Min ...). div 0 is impossible.

Nat.N.toIn nat7 |> Nat.In.div (nat3 |> Nat.N.toMin)
--> Nat 2 of type Nat (In Nat0 (Nat7Plus a))

The remainder after division. remainderBy 0 is impossible.

Nat.N.toIn nat7 |> Nat.In.remainderBy (nat3 |> Nat.N.toMin)
--> Nat 1 of type Nat (In Nat0 (Nat7Plus a))

Subtract a Nat (In ..) safely, but without calculating the new bounds.

nat6 |> Nat.N.toIn
    |> Nat.In.subLossy between1And5
--> is of type Nat (In Nat0 (Nat6Plus a))

If you have both

• the minimum subtracted value
• the maximum subtracted value

at hand, use sub.

Set the minimum lower.

[ Nat.N.toIn nat3, Nat.N.toIn nat4 ]

Elm complains:

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

[ Nat.N.toIn nat3
, Nat.N.toIn nat4 |> Nat.In.lowerMin (nat3 |> Nat.N.toIn)
]

Make it fit into functions with higher maximum.

You should design type annotations as general as possible.

onlyAtMost18 : Nat (In min Nat18)


onlyAtMost18 between3And8 --fine

But once you implement onlyAtMost18, you might use the value in onlyAtMost19.

onlyAtMost18 value =
    -- onlyAtMost19 value --error :(
    onlyAtMost19
        (value |> Nat.In.maxIs nat18 {- works :) -})

lowerMin is also handy in those situations.

Convert a Nat (In ...) to a Nat (Min ...).

squareAInNat =
    Nat.In.dropMax
        >> Nat.Min.toPower (nat2 |> Nat.N.toMin)

Generate a random Nat (In ...) in a range.

Nat (In ...)s from a first to a last value.

from3To10 =
    Nat.In.range (nat3 |> Nat.N.toIn) (nat10 |> Nat.N.toIn)

The resulting List is never empty.