dupin-core
API
Generated with
© 2002-2021 · LAMP/EPFL
© 2002-2021 · LAMP/EPFL
dupin-core/dupin.core/Validator

Validator

dupin.core.Validator
See theValidator companion object
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.

Attributes

Companion:
object
Graph
Supertypes
trait ValidatorBinCompat[F, E, A]
class Object
trait Matchable
class Any

Members list

Concise view

Value members

Concrete methods

def &&(v: Validator[F, E, A])(implicit F: Applicative[F]): Validator[F, E, A]

Alias for combine with $ operator priority

Alias for combine with $ operator priority

Attributes

def andThen(v: Validator[F, E, A])(implicit F: Monad[F]): Validator[F, E, A]

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

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

Attributes

def apply(a: A)(implicit F: Functor[F]): F[ValidatedNec[E, A]]
def comap[AA](f: AA => A): Validator[F, E, AA]

Contravariant map without path changes. Example:

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

Attributes

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

Contravariant map with explicit path prefix.

Contravariant map with explicit path prefix.

Attributes

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

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:

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

Attributes

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.

Attributes

See also:
def combinePE[AA](p: 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.

Attributes

See also:
def combineR(f: A => Boolean, m: 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.

Attributes

See also:
def combineRF(f: A => F[Boolean], m: A => E)(implicit F: Applicative[F]): Validator[F, E, A]
def failureAs[EE](m1: A => EE, ms: A => EE*)(implicit F: Functor[F]): Validator[F, EE, A]

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

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

Attributes

def handleErrorWith(f: Type[E] => Validator[F, E, A])(implicit F: Monad[F]): Validator[F, E, A]
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.

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

Attributes

def mapError[EE](f: E => EE)(implicit F: Functor[F]): Validator[F, EE, A]
def mapK[G[_]](f: FunctionK[F, G]): Validator[G, E, A]
def orElse(v: Validator[F, E, A])(implicit F: Applicative[F]): Validator[F, E, A]

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:

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)

Attributes

def product[B](v: Validator[F, E, B])(implicit FF: Functor[F], FS: Semigroupal[F]): Validator[F, E, (A, B)]
def toParser(implicit F: Functor[F]): IdParser[F, E, A]
def validate(a: A)(implicit F: Functor[F]): F[ValidatedNec[E, A]]
def ||(v: Validator[F, E, A])(implicit F: Applicative[F]): Validator[F, E, A]

Alias for orElse with | operator priority

Alias for orElse with | operator priority

Attributes

Inherited methods

inline def comapP[AA](inline f: AA => A): Validator[F, E, AA]

Contravariant map with macros generated path prefix.

Contravariant map with macros generated path prefix.

Attributes

See also:

[comap]

Inherited from:
ValidatorBinCompat
inline def combineP[AA](inline f: A => AA): PartiallyAppliedCombineP[F, E, A, AA]

Combines with field validator using macros generated path.

Combines with field validator using macros generated path.

Attributes

Inherited from:
ValidatorBinCompat
inline def combinePC[AA](inline 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.

Attributes

Inherited from:
ValidatorBinCompat
inline def combinePI[AA](inline f: A => AA)(implicit V: Validator[F, E, AA], A: Applicative[F]): Validator[F, E, A]

Combines with implicit field validator using macros generated path

Combines with implicit field validator using macros generated path

Attributes

Inherited from:
ValidatorBinCompat
inline def combinePR[AA](inline 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.

Attributes

Inherited from:
ValidatorBinCompat
inline def combinePRF[AA](inline f: A => AA): PartiallyAppliedCombinePRF[F, E, A, AA]

Attributes

Inherited from:
ValidatorBinCompat

Concrete fields

val runF: Context[A] => F[ValidatedNec[E, Unit]]
Generated with
© 2002-2021 · LAMP/EPFL
© 2002-2021 · LAMP/EPFL