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$12570/0x00000001032e9440@441d34ff

val maxValueValidator = ValidatorRule.maxValue(100L)
// maxValueValidator: ValidatorRule[Long, LargerThan[Long]] = yantl.ValidatorRule$$$Lambda$12664/0x0000000103336040@925bca7

val betweenValidator = ValidatorRule.between(0L, 100L)
// betweenValidator: ValidatorRule[Long, SmallerThan[Long] | LargerThan[Long]] = yantl.ValidatorRule$$$Lambda$12665/0x0000000103336440@36c57777

val minLengthOfVectorValidator = ValidatorRule.minLength(2, getLength = (_: Vector[String]).size)
// minLengthOfVectorValidator: ValidatorRule[Vector[String], UnderMinLength[Vector[String]]] = yantl.ValidatorRule$$$Lambda$12582/0x0000000103300440@15fb8ee8

val maxLengthOfVectorValidator = ValidatorRule.maxLength(50, getLength = (_: Vector[String]).size)
// maxLengthOfVectorValidator: ValidatorRule[Vector[String], MaxLengthExceeded[Vector[String]]] = yantl.ValidatorRule$$$Lambda$12668/0x0000000103338840@1a6ed0bf

val minLengthValidator = ValidatorRule.minLength(2)
// minLengthValidator: ValidatorRule[String, UnderMinLength[String]] = yantl.ValidatorRule$$$Lambda$12582/0x0000000103300440@379b18cb

val maxLengthValidator = ValidatorRule.maxLength(50)
// maxLengthValidator: ValidatorRule[String, MaxLengthExceeded[String]] = yantl.ValidatorRule$$$Lambda$12668/0x0000000103338840@713fd2

val nonEmptyValidator = ValidatorRule.nonEmpty(isEmpty = (_: Vector[String]).isEmpty)
// nonEmptyValidator: ValidatorRule[Vector[String], WasEmpty[Vector[String]]] = yantl.ValidatorRule$$$Lambda$12671/0x000000010333a440@34b4bd1a

val nonEmptyStringValidator = ValidatorRule.nonEmptyString
// nonEmptyStringValidator: ValidatorRule[String, WasEmpty[String]] = yantl.ValidatorRule$$$Lambda$12671/0x000000010333a440@4faf67c5

val nonBlankStringValidator = ValidatorRule.nonBlankString
// nonBlankStringValidator: ValidatorRule[String, WasBlank] = yantl.ValidatorRule$$$Lambda$12579/0x00000001032ee840@72aadb2

val withoutSurroundingWhitespaceValidator = ValidatorRule.withoutSurroundingWhitespace
// withoutSurroundingWhitespaceValidator: ValidatorRule[String, HadSurroundingWhitespace] = yantl.ValidatorRule$$$Lambda$12580/0x00000001032eec40@45753c70

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$12584/0x0000000103301440@2d74e10f

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$7@42f39309

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)
// )