Validator Rules

Each ValidatorRule applies a single validation. Many rules are combined to form a Validator.

Built-in Rules

The ValidatorRule object provides several built-in rules:

import yantl.*

val minValueValidator = ValidatorRule.minValue(0L)
// minValueValidator: ValidatorRule[Long, SmallerThan[Long]] = yantl.ValidatorRule$$$Lambda$12439/0x000000010320c840@39d528fe

val maxValueValidator = ValidatorRule.maxValue(100L)
// maxValueValidator: ValidatorRule[Long, LargerThan[Long]] = yantl.ValidatorRule$$$Lambda$12723/0x00000001032e3c40@49f894a8

val betweenValidator = ValidatorRule.between(0L, 100L)
// betweenValidator: ValidatorRule[Long, SmallerThan[Long] | LargerThan[Long]] = yantl.ValidatorRule$$$Lambda$12724/0x00000001032e5840@5f2ceac2

val minLengthOfVectorValidator = ValidatorRule.minLength(2, getLength = (_: Vector[String]).size)
// minLengthOfVectorValidator: ValidatorRule[Vector[String], UnderMinLength[Vector[String]]] = yantl.ValidatorRule$$$Lambda$12449/0x000000010321e840@411bd9ce

val maxLengthOfVectorValidator = ValidatorRule.maxLength(50, getLength = (_: Vector[String]).size)
// maxLengthOfVectorValidator: ValidatorRule[Vector[String], MaxLengthExceeded[Vector[String]]] = yantl.ValidatorRule$$$Lambda$12727/0x00000001032e7440@29016a61

val minLengthValidator = ValidatorRule.minLength(2)
// minLengthValidator: ValidatorRule[String, UnderMinLength[String]] = yantl.ValidatorRule$$$Lambda$12449/0x000000010321e840@644d6c4c

val maxLengthValidator = ValidatorRule.maxLength(50)
// maxLengthValidator: ValidatorRule[String, MaxLengthExceeded[String]] = yantl.ValidatorRule$$$Lambda$12727/0x00000001032e7440@1cc4b6fb

val nonEmptyValidator = ValidatorRule.nonEmpty(isEmpty = (_: Vector[String]).isEmpty)
// nonEmptyValidator: ValidatorRule[Vector[String], WasEmpty[Vector[String]]] = yantl.ValidatorRule$$$Lambda$12730/0x00000001032ea040@977b939

val nonEmptyStringValidator = ValidatorRule.nonEmptyString
// nonEmptyStringValidator: ValidatorRule[String, WasEmpty[String]] = yantl.ValidatorRule$$$Lambda$12730/0x00000001032ea040@44b99f3c

val nonBlankStringValidator = ValidatorRule.nonBlankString
// nonBlankStringValidator: ValidatorRule[String, WasBlank] = yantl.ValidatorRule$$$Lambda$12446/0x0000000103219440@61aa7d7c

val withoutSurroundingWhitespaceValidator = ValidatorRule.withoutSurroundingWhitespace
// withoutSurroundingWhitespaceValidator: ValidatorRule[String, HadSurroundingWhitespace] = yantl.ValidatorRule$$$Lambda$12447/0x000000010321f840@12279d6d

Custom Rules

You can define your own ValidatorRule using the ValidatorRule.of method:

case class NotEven(value: Long)
val isEven = ValidatorRule.of((v: Long) => if v % 2 == 0 then None else Some(NotEven(v)))
// isEven: ValidatorRule[Long, NotEven] = yantl.ValidatorRule$$$Lambda$12733/0x00000001032efc40@32b904e

Validator

The Validator object is used to combine multiple ValidatorRule objects into a single validator.

import yantl.*

val validator = Validator.of(
  ValidatorRule.minValue(0L), ValidatorRule.maxValue(100L), isEven
)
// validator: Validator[Long, SmallerThan[Long] | LargerThan[Long] | NotEven] = yantl.Validator$$anon$6@2feb89e1

validator.validate(50)
// res0: Vector[SmallerThan[Long] | LargerThan[Long] | NotEven] = Vector()

validator.validate(51)
// res1: Vector[SmallerThan[Long] | LargerThan[Long] | NotEven] = Vector(
//   NotEven(value = 51L)
// )

validator.validate(101)
// res2: Vector[SmallerThan[Long] | LargerThan[Long] | NotEven] = Vector(
//   LargerThan(maximum = 100L, actual = 101L),
//   NotEven(value = 101L)
// )