numeric

Module for numeric predicates. Predicates that take type parameters support both shapeless' natural numbers (Nat) and numeric singleton types (which are made available by shapeless' Witness - abbreviated as W in refined) which include subtypes of Int, Long, Double, Char etc.

Example:

scala> import eu.timepit.refined.api.Refined
     | import eu.timepit.refined.numeric.Greater
     | import shapeless.nat._5

scala> refineMV[Greater[_5]](10)
res1: Int Refined Greater[_5] = 10

scala> refineMV[Greater[W.`1.5`.T]](1.6)
res2: Double Refined Greater[W.`1.5`.T] = 1.6

Note: generic.Equal can also be used for numeric types.

Source: numeric.scala

Linear Supertypes

NumericInference, NumericValidate, AnyRef, Any

Type Members

type Divisible[N] = Modulo[N, _0]

Predicate that checks if an integral value is evenly divisible by N.
type Even = Modulo[shapeless.Nat._2, _0]

Predicate that checks if an integral value is evenly divisible by 2.
final case class Greater[N](n: N) extends Product with Serializable

Predicate that checks if a numeric value is greater than N.
type GreaterEqual[N] = Not[Less[N]]

Predicate that checks if a numeric value is greater than or equal to N.
final case class Less[N](n: N) extends Product with Serializable

Predicate that checks if a numeric value is less than N.
type LessEqual[N] = Not[Greater[N]]

Predicate that checks if a numeric value is less than or equal to N.
final case class Modulo[N, O](n: N, o: O) extends Product with Serializable

Predicate that checks if an integral value modulo N is O.
type Negative = Less[_0]

Predicate that checks if a numeric value is negative (< 0).
type NonDivisible[N] = Not[Divisible[N]]

Predicate that checks if an integral value is not evenly divisible by N.
type NonNegative = Not[Negative]

Predicate that checks if a numeric value is zero or positive (>= 0).
type NonPositive = Not[Positive]

Predicate that checks if a numeric value is zero or negative (<= 0).
type Odd = Not[Even]

Predicate that checks if an integral value is not evenly divisible by 2.
type Positive = Greater[_0]

Predicate that checks if a numeric value is positive (> 0).

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
object Interval
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
implicit def greaterInferenceNat[A <: Nat, B <: Nat](implicit ta: ToInt[A], tb: ToInt[B]): ==>[Greater[A], Greater[B]]

Definition Classes
NumericInference
implicit def greaterInferenceWit[C, A <: C, B <: C](implicit wa: Aux[A], wb: Aux[B], nc: Numeric[C]): ==>[Greater[A], Greater[B]]

Definition Classes
NumericInference
implicit def greaterInferenceWitNat[C, A <: C, B <: Nat](implicit wa: Aux[A], tb: ToInt[B], nc: Numeric[C]): ==>[Greater[A], Greater[B]]

Definition Classes
NumericInference
implicit def greaterValidateNat[N <: Nat, T](implicit tn: ToInt[N], wn: Aux[N], nt: Numeric[T]): Plain[T, Greater[N]]

Definition Classes
NumericValidate
implicit def greaterValidateWit[T, N <: T](implicit wn: Aux[N], nt: Numeric[T]): Plain[T, Greater[N]]

Definition Classes
NumericValidate
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
implicit def lessInferenceNat[A <: Nat, B <: Nat](implicit ta: ToInt[A], tb: ToInt[B]): ==>[Less[A], Less[B]]

Definition Classes
NumericInference
implicit def lessInferenceWit[C, A <: C, B <: C](implicit wa: Aux[A], wb: Aux[B], nc: Numeric[C]): ==>[Less[A], Less[B]]

Definition Classes
NumericInference
implicit def lessInferenceWitNat[C, A <: C, B <: Nat](implicit wa: Aux[A], tb: ToInt[B], nc: Numeric[C]): ==>[Less[A], Less[B]]

Definition Classes
NumericInference
implicit def lessValidateNat[N <: Nat, T](implicit tn: ToInt[N], wn: Aux[N], nt: Numeric[T]): Plain[T, Less[N]]

Definition Classes
NumericValidate
implicit def lessValidateWit[T, N <: T](implicit wn: Aux[N], nt: Numeric[T]): Plain[T, Less[N]]

Definition Classes
NumericValidate
def moduloValidateNat[N <: Nat, O <: Nat, T](implicit tn: ToInt[N], to: ToInt[O], wn: Aux[N], wo: Aux[O], nt: Numeric[T]): Plain[T, Modulo[N, O]]

Definition Classes
NumericValidate
implicit def moduloValidateNatIntegral[N <: Nat, O <: Nat, T](implicit tn: ToInt[N], to: ToInt[O], wn: Aux[N], wo: Aux[O], it: Integral[T]): Plain[T, Modulo[N, O]]

Definition Classes
NumericValidate
def moduloValidateWit[T, N <: T, O <: T](implicit wn: Aux[N], wo: Aux[O], nt: Numeric[T]): Plain[T, Modulo[N, O]]

Definition Classes
NumericValidate
implicit def moduloValidateWitIntegral[T, N <: T, O <: T](implicit wn: Aux[N], wo: Aux[O], it: Integral[T]): Plain[T, Modulo[N, O]]

Definition Classes
NumericValidate
implicit def moduloValidateWitNatIntegral[T, N <: T, O <: Nat](implicit wn: Aux[N], to: ToInt[O], wo: Aux[O], it: Integral[T]): Plain[T, Modulo[N, O]]

Definition Classes
NumericValidate
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

object numeric extends NumericValidate with NumericInference

Type Members

type Divisible[N] = Modulo[N, _0]

type Even = Modulo[shapeless.Nat._2, _0]

final case class Greater[N](n: N) extends Product with Serializable

type GreaterEqual[N] = Not[Less[N]]

final case class Less[N](n: N) extends Product with Serializable

type LessEqual[N] = Not[Greater[N]]

final case class Modulo[N, O](n: N, o: O) extends Product with Serializable

type Negative = Less[_0]

type NonDivisible[N] = Not[Divisible[N]]

type NonNegative = Not[Negative]

type NonPositive = Not[Positive]

type Odd = Not[Even]

type Positive = Greater[_0]

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object Interval

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

implicit def greaterInferenceNat[A <: Nat, B <: Nat](implicit ta: ToInt[A], tb: ToInt[B]): ==>[Greater[A], Greater[B]]

implicit def greaterInferenceWit[C, A <: C, B <: C](implicit wa: Aux[A], wb: Aux[B], nc: Numeric[C]): ==>[Greater[A], Greater[B]]

implicit def greaterInferenceWitNat[C, A <: C, B <: Nat](implicit wa: Aux[A], tb: ToInt[B], nc: Numeric[C]): ==>[Greater[A], Greater[B]]

implicit def greaterValidateNat[N <: Nat, T](implicit tn: ToInt[N], wn: Aux[N], nt: Numeric[T]): Plain[T, Greater[N]]

implicit def greaterValidateWit[T, N <: T](implicit wn: Aux[N], nt: Numeric[T]): Plain[T, Greater[N]]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

implicit def lessInferenceNat[A <: Nat, B <: Nat](implicit ta: ToInt[A], tb: ToInt[B]): ==>[Less[A], Less[B]]

implicit def lessInferenceWit[C, A <: C, B <: C](implicit wa: Aux[A], wb: Aux[B], nc: Numeric[C]): ==>[Less[A], Less[B]]

implicit def lessInferenceWitNat[C, A <: C, B <: Nat](implicit wa: Aux[A], tb: ToInt[B], nc: Numeric[C]): ==>[Less[A], Less[B]]

implicit def lessValidateNat[N <: Nat, T](implicit tn: ToInt[N], wn: Aux[N], nt: Numeric[T]): Plain[T, Less[N]]

implicit def lessValidateWit[T, N <: T](implicit wn: Aux[N], nt: Numeric[T]): Plain[T, Less[N]]

def moduloValidateNat[N <: Nat, O <: Nat, T](implicit tn: ToInt[N], to: ToInt[O], wn: Aux[N], wo: Aux[O], nt: Numeric[T]): Plain[T, Modulo[N, O]]

implicit def moduloValidateNatIntegral[N <: Nat, O <: Nat, T](implicit tn: ToInt[N], to: ToInt[O], wn: Aux[N], wo: Aux[O], it: Integral[T]): Plain[T, Modulo[N, O]]

def moduloValidateWit[T, N <: T, O <: T](implicit wn: Aux[N], wo: Aux[O], nt: Numeric[T]): Plain[T, Modulo[N, O]]

implicit def moduloValidateWitIntegral[T, N <: T, O <: T](implicit wn: Aux[N], wo: Aux[O], it: Integral[T]): Plain[T, Modulo[N, O]]

implicit def moduloValidateWitNatIntegral[T, N <: T, O <: Nat](implicit wn: Aux[N], to: ToInt[O], wo: Aux[O], it: Integral[T]): Plain[T, Modulo[N, O]]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from NumericInference

Inherited from NumericValidate

Inherited from AnyRef

Inherited from Any

Ungrouped