final class Validator[F[_], E, A] extends ValidatorBinCompat[F, E, A]

A type class that defines how to validate an instance of A. Can be thought of as a A => F[ValidatedNec[E, Unit]] function.

Linear Supertypes
ValidatorBinCompat[F, E, A], AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Validator
  2. ValidatorBinCompat
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. def &&(v: Validator[F, E, A])(implicit F: Applicative[F]): Validator[F, E, A]

    Alias for combine with $ operator priority

  4. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  5. def andThen(v: Validator[F, E, A])(implicit F: Monad[F]): Validator[F, E, A]

    Combines two validators of the same type into one.

    Combines two validators of the same type into one. If first validator fails, second one is not invoked. Example:

    scala> val value = "value"
scala> val v1 = dupin.basic.BasicValidator.failure[String](_ => "failure1")
scala> val v2 = dupin.basic.BasicValidator.failure[String](_ => "failure2")
scala> val v3 = dupin.basic.BasicValidator.success[String]

scala> (v1 andThen v2).validate(value)
res0: cats.Id[cats.data.ValidatedNec[String,User]] = Invalid(Chain(failure1))

scala> (v3 andThen v2).validate(value)
res1: cats.Id[cats.data.ValidatedNec[String,User]] = Invalid(Chain(failure2))
  6. def apply(a: A)(implicit F: Functor[F]): F[ValidatedNec[E, A]]
  7. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  8. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
  9. def comap[AA](f: (AA) => A): Validator[F, E, AA]

    Contravariant map without path changes.

    Contravariant map without path changes. Example:

    scala> case class User(age: Int)
scala> val user = User(1)
scala> val validator = dupin.basic.BasicValidator.failure[Int](c => s"${c.path} is wrong")

scala> validator.comap[User](_.age).validate(user)
res0: cats.Id[cats.data.ValidatedNec[String,User]] = Invalid(Chain(. is wrong))

scala> validator.comapP[User](_.age).validate(user)
res1: cats.Id[cats.data.ValidatedNec[String,User]] = Invalid(Chain(.age is wrong))
  10. macro def comapP[AA](f: (AA) => A): Validator[F, E, AA]

    Contravariant map with macros generated path prefix.

    Contravariant map with macros generated path prefix.

    Definition Classes
    ValidatorBinCompat
    See also

    [comap]

  11. def comapPE[AA](p: dupin.Path, f: (AA) => A): Validator[F, E, AA]

    Contravariant map with explicit path prefix.

  12. def combine(v: Validator[F, E, A])(implicit F: Applicative[F]): Validator[F, E, A]

    Combines two validators of the same type into one.

    Combines two validators of the same type into one. If either validator fails, error is returned. If both validators fail, errors from both validators are returned. Example:

    scala> val value = "value"
scala> val v1 = dupin.basic.BasicValidator.failure[String](_ => "failure1")
scala> val v2 = dupin.basic.BasicValidator.failure[String](_ => "failure2")
scala> val v3 = dupin.basic.BasicValidator.success[String]

scala> (v1 combine v2).validate(value)
res0: cats.Id[cats.data.ValidatedNec[String,User]] = Invalid(Chain(failure1, failure2))

scala> (v3 combine v2).validate(value)
res1: cats.Id[cats.data.ValidatedNec[String,User]] = Invalid(Chain(failure2))
  13. def combineC(f: (A) => Validator[F, E, A])(implicit F: Applicative[F]): Validator[F, E, A]

    Combines this with validator from context.

    Combines this with validator from context.

    See also

    combine

  14. macro def combineP[AA](f: (A) => AA): PartiallyAppliedCombineP[F, E, A, AA]

    Combines with field validator using macros generated path.

    Combines with field validator using macros generated path.

    Definition Classes
    ValidatorBinCompat
  15. macro def combinePC[AA](f: (A) => AA): PartiallyAppliedCombinePC[F, E, A, AA]

    Combines with field validator from context using macros generated path.

    Combines with field validator from context using macros generated path.

    Definition Classes
    ValidatorBinCompat
  16. def combinePE[AA](p: dupin.Path, f: (A) => AA)(v: Validator[F, E, AA])(implicit F: Applicative[F]): Validator[F, E, A]

    Combines this with field validator using explicit path.

    Combines this with field validator using explicit path.

    See also

    combine

  17. macro def combinePI[AA](f: (A) => AA)(implicit AA: Validator[F, E, AA]): Validator[F, E, A]

    Combines with implicit field validator using macros generated path

    Combines with implicit field validator using macros generated path

    Definition Classes
    ValidatorBinCompat
  18. macro def combinePR[AA](f: (A) => AA): PartiallyAppliedCombinePR[F, E, A, AA]

    Combines with field validator passed by separate arguments using macros generated path.

    Combines with field validator passed by separate arguments using macros generated path.

    Definition Classes
    ValidatorBinCompat
  19. macro def combinePRF[AA](f: (A) => AA): PartiallyAppliedCombinePRF[F, E, A, AA]
    Definition Classes
    ValidatorBinCompat
  20. def combineR(f: (A) => Boolean, m: dupin.MessageBuilder[A, E])(implicit F: Applicative[F]): Validator[F, E, A]

    Combines this with root validator passed by separate arguments.

    Combines this with root validator passed by separate arguments.

    See also

    combine

  21. def combineRF(f: (A) => F[Boolean], m: dupin.MessageBuilder[A, E])(implicit F: Applicative[F]): Validator[F, E, A]
  22. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  23. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  24. def failureAs[EE](m1: dupin.MessageBuilder[A, EE], ms: dupin.MessageBuilder[A, EE]*)(implicit F: Functor[F]): Validator[F, EE, A]

    Replaces failure messages with supplied values.

    Replaces failure messages with supplied values. Optimized version of .handleErrorWith(_ => Validator.failure(m1, ms))

  25. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  26. def handleErrorWith(f: (NonEmptyChain[E]) => Validator[F, E, A])(implicit F: Monad[F]): Validator[F, E, A]
  27. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  28. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  29. def liftToTraverseP[G[_]](implicit F: Applicative[F], G: Traverse[G]): Validator[F, E, G[A]]

    Lifts validator to G[_] type using Traverse instance, adds index as path prefix.

  30. def mapError[EE](f: (E) => EE)(implicit F: Functor[F]): Validator[F, EE, A]
  31. def mapK[G[_]](f: ~>[F, G]): Validator[G, E, A]
  32. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  33. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  34. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  35. def orElse(v: Validator[F, E, A])(implicit F: Applicative[F]): Validator[F, E, A]

    Combines two validators of the same type into one.

    Combines two validators of the same type into one. If either validator fails, success is returned. If both validators fail, errors from right validator are returned. Example:

    scala> val value = "value"
scala> val v1 = dupin.basic.BasicValidator.failure[String](_ => "failure1")
scala> val v2 = dupin.basic.BasicValidator.failure[String](_ => "failure2")
scala> val v3 = dupin.basic.BasicValidator.success[String]

scala> (v1 orElse v2).validate(value)
res0: cats.Id[cats.data.ValidatedNec[String,User]] = Invalid(Chain(failure2))

scala> (v3 orElse v2).validate(value)
res1: cats.Id[cats.data.ValidatedNec[String,User]] = Valid(value)
  36. def product[B](v: Validator[F, E, B])(implicit FF: Functor[F], FS: Semigroupal[F]): Validator[F, E, (A, B)]
  37. val runF: (dupin.Context[A]) => F[ValidatedNec[E, Unit]]
  38. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  39. def toParser(implicit F: Functor[F]): dupin.IdParser[F, E, A]
  40. def toString(): String
    Definition Classes
    AnyRef → Any
  41. def validate(a: A)(implicit F: Functor[F]): F[ValidatedNec[E, A]]
  42. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  43. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  44. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  45. def ||(v: Validator[F, E, A])(implicit F: Applicative[F]): Validator[F, E, A]

    Alias for orElse with | operator priority

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable]) @Deprecated
    Deprecated

Inherited from ValidatorBinCompat[F, E, A]

Inherited from AnyRef

Inherited from Any

Ungrouped