Assertion

An Assertion[A] is essentially a composable predicate from A => Boolean. They can be composed with standard Boolean operators of &&, || and !. This is primarily intended to be used with Newtype and Subtype, enhancing them with compile-time time validation.

For example, if you'd like to validate that a particular Int is precisely 4 digits long, you can create the following refined Newtype. (Note that the syntax is slightly difference between Scala 2 and Scala 3).

type Pin = Pin.Type
object Pin extends Newtype[Int] {
  // Scala 2 Syntax
  def assertion =
    assert(Assertion.between(1000, 9999))

  // Scala 3 Syntax
  override inline def assertion =
    Assertion.between(1000, 9999)
}

// PowerOfTwo(1000) compiles
// PowerOfTwo(5412) compiles
// PowerOfTwo(34567) fails with "34567 did not satisfy between(1000, 9999)"
// PowerOfTwo(234) fails with "123 did not satisfy between(1000, 9999)"

Linear Supertypes

AnyRef, Any

Type Members

sealed trait Regex extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

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

Definition Classes
AnyRef → Any
object Regex
val anything: Assertion[Any]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def between[A](min: A, max: A)(implicit ordering: Ordering[A]): Assertion[A]

Ensures the value falls between a given min and max (inclusive).
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def contains(string: String): Assertion[String]
def divisibleBy[A](n: A)(implicit numeric: Numeric[A]): Assertion[A]
def endsWith(suffix: String): Assertion[String]
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equalTo[A](value: A): Assertion[A]
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
def greaterThan[A](value: A)(implicit ordering: Ordering[A]): Assertion[A]
def greaterThanOrEqualTo[A](value: A)(implicit ordering: Ordering[A]): Assertion[A]
def hasLength(lengthAssertion: Assertion[Int]): Assertion[String]
def hashCode(): Int

Definition Classes
AnyRef → Any
val isEmptyString: Assertion[String]
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def lessThan[A](value: A)(implicit ordering: Ordering[A]): Assertion[A]
def lessThanOrEqualTo[A](value: A)(implicit ordering: Ordering[A]): Assertion[A]
def matches(regex: scala.util.matching.Regex): Assertion[String]

Matches a scala.util.matching.Regex.
Matches a scala.util.matching.Regex.
In order to use this for compile-time Assertions, make sure to use the string literal extension method, e.g.:
```
Assertion.matches("\\w+@\\d{3,5}".r)
```
def matches(regexString: String): Assertion[String]
def matches(regex: Regex): Assertion[String]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
val never: Assertion[Any]
def notEqualTo[A](value: A): Assertion[A]
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef

def powerOf[A](base: A)(implicit numeric: Numeric[A]): Assertion[A]

Ensures that the value is a power of the given base.

type PowerOfTwo = PowerOfTwo.Type
object PowerOfTwo extends Newtype[Int] {
  def assertion =
    assert(Assertion.powerOf(2))
}

// PowerOfTwo(1024) compiles
// PowerOfTwo(1025) fails

def startsWith(prefix: String): Assertion[String]
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( ... )

Related Docs: trait Assertion | package prelude

object Assertion

Type Members

sealed trait Regex extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object Regex

val anything: Assertion[Any]

final def asInstanceOf[T0]: T0

def between[A](min: A, max: A)(implicit ordering: Ordering[A]): Assertion[A]

def clone(): AnyRef

def contains(string: String): Assertion[String]

def divisibleBy[A](n: A)(implicit numeric: Numeric[A]): Assertion[A]

def endsWith(suffix: String): Assertion[String]

final def eq(arg0: AnyRef): Boolean

def equalTo[A](value: A): Assertion[A]

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def greaterThan[A](value: A)(implicit ordering: Ordering[A]): Assertion[A]

def greaterThanOrEqualTo[A](value: A)(implicit ordering: Ordering[A]): Assertion[A]

def hasLength(lengthAssertion: Assertion[Int]): Assertion[String]

def hashCode(): Int

val isEmptyString: Assertion[String]

final def isInstanceOf[T0]: Boolean

def lessThan[A](value: A)(implicit ordering: Ordering[A]): Assertion[A]

def lessThanOrEqualTo[A](value: A)(implicit ordering: Ordering[A]): Assertion[A]

def matches(regex: scala.util.matching.Regex): Assertion[String]

def matches(regexString: String): Assertion[String]

def matches(regex: Regex): Assertion[String]

final def ne(arg0: AnyRef): Boolean

val never: Assertion[Any]

def notEqualTo[A](value: A): Assertion[A]

final def notify(): Unit

final def notifyAll(): Unit

def powerOf[A](base: A)(implicit numeric: Numeric[A]): Assertion[A]

def startsWith(prefix: String): Assertion[String]

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 AnyRef

Inherited from Any

Ungrouped