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$12774/0x00000001032ec840@789ad224

val maxValueValidator = ValidatorRule.maxValue(100L)
// maxValueValidator: ValidatorRule[Long, LargerThan[Long]] = yantl.ValidatorRule$$$Lambda$12868/0x0000000103337440@3610d27f

val betweenValidator = ValidatorRule.between(0L, 100L)
// betweenValidator: ValidatorRule[Long, SmallerThan[Long] | LargerThan[Long]] = yantl.ValidatorRule$$$Lambda$12869/0x0000000103339040@1d27c53a

val minLengthOfVectorValidator = ValidatorRule.minLength(2, getLength = (_: Vector[String]).size)
// minLengthOfVectorValidator: ValidatorRule[Vector[String], UnderMinLength[Vector[String]]] = yantl.ValidatorRule$$$Lambda$12786/0x00000001032f5840@7636fef3

val maxLengthOfVectorValidator = ValidatorRule.maxLength(50, getLength = (_: Vector[String]).size)
// maxLengthOfVectorValidator: ValidatorRule[Vector[String], MaxLengthExceeded[Vector[String]]] = yantl.ValidatorRule$$$Lambda$12872/0x000000010333ac40@58cd9a98

val minLengthValidator = ValidatorRule.minLength(2)
// minLengthValidator: ValidatorRule[String, UnderMinLength[String]] = yantl.ValidatorRule$$$Lambda$12786/0x00000001032f5840@703beaa1

val maxLengthValidator = ValidatorRule.maxLength(50)
// maxLengthValidator: ValidatorRule[String, MaxLengthExceeded[String]] = yantl.ValidatorRule$$$Lambda$12872/0x000000010333ac40@41e6a312

val nonEmptyValidator = ValidatorRule.nonEmpty(isEmpty = (_: Vector[String]).isEmpty)
// nonEmptyValidator: ValidatorRule[Vector[String], WasEmpty[Vector[String]]] = yantl.ValidatorRule$$$Lambda$12875/0x000000010333d840@44c0eb65

val nonEmptyStringValidator = ValidatorRule.nonEmptyString
// nonEmptyStringValidator: ValidatorRule[String, WasEmpty[String]] = yantl.ValidatorRule$$$Lambda$12875/0x000000010333d840@50a2415e

val nonBlankStringValidator = ValidatorRule.nonBlankString
// nonBlankStringValidator: ValidatorRule[String, WasBlank] = yantl.ValidatorRule$$$Lambda$12783/0x00000001032f7440@59bd5494

val withoutSurroundingWhitespaceValidator = ValidatorRule.withoutSurroundingWhitespace
// withoutSurroundingWhitespaceValidator: ValidatorRule[String, HadSurroundingWhitespace] = yantl.ValidatorRule$$$Lambda$12784/0x00000001032f6840@700c676d

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$12788/0x00000001032f4840@1a13c20

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@7230a4b2

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