PackagesReroutesAboutlamdera.com

lue-bird/elm-bounded-nat/15.0.0

NOTE: the latest version is 35.0.0

READMEAboutVersionsSourceModules

InNat

Operations when you know the maximum of the Nat (ArgIn minimum maximum ifN_).

For example for the argument in

toHexChar : Nat (ArgIn min_ Nat15 ifN_) -> Char

you should use InNat operations.

If the maximum isn't known, use the operations in MinNat.

create

clamp

Nat (ArgIn minNewMax atLeastNewMax newMaxIfN_)
-> { lowest :
Nat
(N
lowest
atLeastLowest_
(Is lowestToMin_ To min)
(Is lowestToMinNewMax_ To minNewMax)
)
}
-> Nat (ArgIn min max ifN_)
-> Nat (In lowest atLeastNewMax)

Cap the Nat to at most a number.

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

lowest can be a number <= the minimum.

Nat (ArgIn newMin max lowerIfN_)
-> Nat (ArgIn min_ max ifN_)
-> Nat (In newMin max)

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

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


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

compare

is :
Nat
(N
(Nat1Plus valueMinus1)
atLeastValue
(Is a_ To (Nat1Plus atLeastValueMinus1))
(Is valueToMax_ To max)
)
-> { lowest :
Nat
(N
lowest
atLeastLowest_
(Is lowestToMin_ To min)
(Is minToValue_ To (Nat1Plus valueMinus1))
)
}
-> Nat (ArgIn min max ifN_)
(Nat (In lowest atLeastValueMinus1))
(Nat (In (Nat1Plus valueMinus1) atLeastValue))
(Nat (In (Nat2Plus valueMinus1) max))

Is the Nat LessOrEqualOrGreater than a given number?

lowest can be a number <= the minimum.

giveAPresent { age } =
    case age |> InNat.is nat18 { lowest = nat0 } of
        Nat.Less age ->
            toy { age = age }


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


        Nat.Equal _ ->
            bigPresent


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


experience :
    { age : Nat (ArgIn (Nat19Plus orOlder) max ifN_) }
    -> Experience
Nat
(N
lowerBound
(Nat1Plus atLeastLowerBoundMinus1)
(Is lowerBoundToUpperBound_ To upperBound)
lowerBoundIs_
)
-> Nat
(N
upperBound
atLeastUpperBound
(Is upperBoundToMax_ To max)
upperBoundIs_
)
-> { lowest :
Nat
(N
lowest
atLeastLowest_
(Is lowestToMin_ To min)
(Is minToLowerBound_ To lowerBound)
)
}
-> Nat (ArgIn min max ifN_)
(Nat (In lowest atLeastLowerBoundMinus1))
(Nat (In lowerBound atLeastUpperBound))
(Nat (In (Nat1Plus upperBound) max))

Compared to a range from a lower to an upper bound, is the Nat BelowOrInOrAboveRange?

lowest can be a number <= the minimum.

justIfBetween3And10 nat =
    case nat |> InNat.isInRange nat3 nat10 { lowest = nat0 } of
        Nat.InRange ->
            Just


        _ ->
            Nothing


justIfBetween3And10 nat9
--> Just (Nat 9)


justIfBetween3And10 nat123
--> Nothing
Nat
(N
lowerBound
(Nat1Plus atLeastLowerBoundMinus1)
(Is atLeastRange_ To max)
is_
)
-> { lowest :
Nat
(N
lowest
atLeastLowest
(Is lowestToMin To min)
(Is (Nat1Plus lowestToLowerBound_) To lowerBound)
)
}
-> Nat (ArgIn min max ifN_)
(Nat (In lowest atLeastLowerBoundMinus1))
(Nat (In lowerBound max))

Is the Nat BelowOrAtLeast as big as a given number?

lowest can be a number <= the minimum.

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


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


        Nat.EqualOrGreater age ->
            Just (vote { age = age })
Nat
(N
upperBound
atLeastUpperBound
(Is (Nat1Plus greaterRange_) To max)
is_
)
-> { lowest :
Nat
(N
lowest
atLeastLowest_
(Is lowestToMin_ To min)
(Is minToUpperBound_ To upperBound)
)
}
-> Nat (ArgIn min max ifN_)
(Nat (In lowest atLeastUpperBound))
(Nat (In (Nat1Plus upperBound) max))

Is the Nat AtMostOrAbove a given number?

lowest can be a number <= the minimum.

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


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


        Nat.Above ->
            Nothing

modify

add :
Nat
(N added atLeastAdded_ (Is min To sumMin) (Is max To sumMax))
-> Nat (ArgIn min max ifN_)
-> Nat (In sumMin sumMax)

Add a Nat (N ...).

between70And100
    |> InNat.add nat7
--> : Nat (In Nat77 (Nat107Plus a_))
sub :
Nat
(N
subbed_
atLeastSubbed_
(Is differenceMin To min)
(Is differenceMax To max)
)
-> Nat (ArgIn min max ifN_)
-> Nat (In differenceMin differenceMax)

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

between7And10
    |> InNat.sub nat7
--> : Nat (In Nat0 (Nat3Plus a_))
Nat
(N minAdded atLeastMinAdded_ (Is min To sumMin) minAddedIs_)
-> Nat
(N maxAdded atLeastMaxAdded_ (Is max To sumMax) maxAddedIs_)
-> Nat (ArgIn minAdded maxAdded addedIfN_)
-> Nat (ArgIn min max ifN_)
-> Nat (In sumMin sumMax)

Add a Nat (In ...).

The first 2 arguments are

  • the minimum added value

  • the maximum added value

between3And10
    |> InNat.addIn nat1 nat12 between1And12
--> : Nat (In Nat4 (Nat22Plus a_))
Nat
(N
minSubbed
atLeastMinSubbed_
(Is differenceMax To max)
minSubbedIs_
)
-> Nat
(N
maxSubbed
atLeastMaxSubbed_
(Is differenceMin To min)
maxSubbedIs_
)
-> Nat (ArgIn minSubbed maxSubbed subbedIfN_)
-> Nat (ArgIn min max ifN_)
-> Nat (In differenceMin differenceMax)

Subtract a Nat (ArgIn ...).

The first 2 arguments are

  • the minimum subtracted value

  • the maximum subtracted value

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

drop information

value : Nat (ArgIn min max ifN_) -> Nat (In min max)

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
]

extra

Nat (ArgIn minLowerBound maxLowerBound lowerBoundIfN_)
-> Nat (ArgIn maxLowerBound maxUpperBound upperBoundIfN_)
-> Codec String (Nat (In minLowerBound maxUpperBound))

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

Modules

About this package serverReroutesreroutes.json
Pages and docs rendering from package.elm-lang.org, © 2012-2020 Evan Czaplicki. © 2026 Lamdera