Fields/jap.fields.syntax/FieldOps

FieldOps

final class FieldOps[P, F[_], V[_], E](field: Field[P]) extends AnyVal
Source:
GenericSyntax.scala
class AnyVal
trait Matchable
class Any

Value members

Concrete methods

def !==[C](compared: => C)(implicit F: Effect[F], V: Validated[V], FW: FailWithCompare[E, P], C: FieldCompare[P, C]): Rule[F, V, E]

Alias for notEqualTo

Alias for notEqualTo

Source:
GenericSyntax.scala
def ===[C](compared: => C)(implicit F: Effect[F], V: Validated[V], FW: FailWithCompare[E, P], C: FieldCompare[P, C]): Rule[F, V, E]

Alias for equalTo

Alias for equalTo

Source:
GenericSyntax.scala
def all(f: Field[P] => Rule[F, V, E]*)(implicit F: Effect[F], V: Validated[V]): Rule[F, V, E]

Combines all validations using AND

Combines all validations using AND

Source:
GenericSyntax.scala
def any(f: Field[P] => Rule[F, V, E]*)(implicit F: Effect[F], V: Validated[V]): Rule[F, V, E]

Combines all validations using OR

Combines all validations using OR

Source:
GenericSyntax.scala
def assert(test: P => Boolean, error: Field[P] => E)(implicit F: Effect[F], V: Validated[V]): Rule[F, V, E]

Like Rule.ensure but for explicit error

Like Rule.ensure but for explicit error

Source:
GenericSyntax.scala
def assertF(test: P => F[Boolean], error: Field[P] => E)(implicit F: Effect[F], V: Validated[V]): Rule[F, V, E]

Like Rule.ensureF but for explicit error

Like Rule.ensureF but for explicit error

Source:
GenericSyntax.scala
def check(f: Field[P] => V[E])(implicit F: Effect[F]): Rule[F, V, E]

Returns Suspended Outcome of applying f to field

Returns Suspended Outcome of applying f to field

Source:
GenericSyntax.scala
def checkF(f: Field[P] => Rule[F, V, E])(implicit F: Effect[F]): Rule[F, V, E]

Returns Defered Outcome of applying f to field

Returns Defered Outcome of applying f to field

Source:
GenericSyntax.scala
def ensure(test: P => Boolean, error: Field[P] => V[E])(implicit F: Effect[F], V: Validated[V]): Rule[F, V, E]
def ensureF(test: P => F[Boolean], error: Field[P] => V[E])(implicit F: Effect[F], V: Validated[V]): Rule[F, V, E]
def equalTo[C](compared: => C)(implicit F: Effect[F], V: Validated[V], FW: FailWithCompare[E, P], C: FieldCompare[P, C]): Rule[F, V, E]

Validates that jap.fields.Field#value is equal to compared

Validates that jap.fields.Field#value is equal to compared

Source:
GenericSyntax.scala
def in(seq: => Seq[P])(implicit F: Effect[F], V: Validated[V], FW: FailWithOneOf[E, P]): Rule[F, V, E]

Validates that jap.fields.Field#value is contained by seq

Validates that jap.fields.Field#value is contained by seq

Source:
GenericSyntax.scala
def notEqualTo[C](compared: => C)(implicit F: Effect[F], V: Validated[V], FW: FailWithCompare[E, P], C: FieldCompare[P, C]): Rule[F, V, E]

Validates that jap.fields.Field#value is not equal to compared

Validates that jap.fields.Field#value is not equal to compared

Source:
GenericSyntax.scala
def unless(test: => Boolean)(f: Field[P] => Rule[F, V, E])(implicit F: Effect[F], V: Validated[V]): Rule[F, V, E]

Runs validation only if false

Runs validation only if false

Source:
GenericSyntax.scala
def validate(implicit P: ValidationPolicy[P, F, V, E]): Rule[F, V, E]

Validates jap.fields.Field using implicit ValidationPolicy

Validates jap.fields.Field using implicit ValidationPolicy

Source:
GenericSyntax.scala
def validateEither(implicit F: Effect[F], V: Validated[V], P: ValidationPolicy[P, F, V, E], E: HasErrors[V]): F[Either[List[E], P]]

Validates jap.fields.Field using implicit ValidationPolicy

Validates jap.fields.Field using implicit ValidationPolicy

Source:
GenericSyntax.scala
def when(test: => Boolean)(f: Field[P] => Rule[F, V, E])(implicit F: Effect[F], V: Validated[V]): Rule[F, V, E]

Runs validation only if true

Runs validation only if true

Source:
GenericSyntax.scala
def when(test: P => Boolean)(rule: Field[P] => Rule[F, V, E])(implicit F: Effect[F], V: Validated[V]): Rule[F, V, E]
def whenF(test: P => F[Boolean])(rule: Field[P] => Rule[F, V, E])(implicit F: Effect[F], V: Validated[V]): Rule[F, V, E]
def whenType[PP <: P](rule: Field[PP] => Rule[F, V, E])(implicit F: Effect[F], V: Validated[V], CT: ClassTag[PP]): Rule[F, V, E]

Runs rule for subtype PP else is valid

Runs rule for subtype PP else is valid

Source:
GenericSyntax.scala