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$13192/0x0000000103460440@7cc6569a

val maxValueValidator = ValidatorRule.maxValue(100L)
// maxValueValidator: ValidatorRule[Long, LargerThan[Long]] = yantl.ValidatorRule$$$Lambda$13472/0x0000000103534c40@52554783

val betweenValidator = ValidatorRule.between(0L, 100L)
// betweenValidator: ValidatorRule[Long, SmallerThan[Long] | LargerThan[Long]] = yantl.ValidatorRule$$$Lambda$13473/0x0000000103536840@31404e87

val minLengthOfVectorValidator = ValidatorRule.minLength(2, getLength = (_: Vector[String]).size)
// minLengthOfVectorValidator: ValidatorRule[Vector[String], UnderMinLength[Vector[String]]] = yantl.ValidatorRule$$$Lambda$13202/0x0000000103463c40@4a45d097

val maxLengthOfVectorValidator = ValidatorRule.maxLength(50, getLength = (_: Vector[String]).size)
// maxLengthOfVectorValidator: ValidatorRule[Vector[String], MaxLengthExceeded[Vector[String]]] = yantl.ValidatorRule$$$Lambda$13476/0x0000000103538440@790a7f89

val minLengthValidator = ValidatorRule.minLength(2)
// minLengthValidator: ValidatorRule[String, UnderMinLength[String]] = yantl.ValidatorRule$$$Lambda$13202/0x0000000103463c40@3df3fcb9

val maxLengthValidator = ValidatorRule.maxLength(50)
// maxLengthValidator: ValidatorRule[String, MaxLengthExceeded[String]] = yantl.ValidatorRule$$$Lambda$13476/0x0000000103538440@46e4e9

val nonEmptyValidator = ValidatorRule.nonEmpty(isEmpty = (_: Vector[String]).isEmpty)
// nonEmptyValidator: ValidatorRule[Vector[String], WasEmpty[Vector[String]]] = yantl.ValidatorRule$$$Lambda$13479/0x000000010353b040@596739c6

val nonEmptyStringValidator = ValidatorRule.nonEmptyString
// nonEmptyStringValidator: ValidatorRule[String, WasEmpty[String]] = yantl.ValidatorRule$$$Lambda$13479/0x000000010353b040@1d17d363

val nonBlankStringValidator = ValidatorRule.nonBlankString
// nonBlankStringValidator: ValidatorRule[String, WasBlank] = yantl.ValidatorRule$$$Lambda$13199/0x0000000103464040@21a11c0

val withoutSurroundingWhitespaceValidator = ValidatorRule.withoutSurroundingWhitespace
// withoutSurroundingWhitespaceValidator: ValidatorRule[String, HadSurroundingWhitespace] = yantl.ValidatorRule$$$Lambda$13200/0x0000000103464440@32982c3d

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$13482/0x000000010353fc40@37544559

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@51e6dca1

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