fields-core/jap.fields/Rule

Rule

object Rule
class Object
trait Matchable
class Any
Rule.type

Type members

Classlikes

final implicit class RuleOps[F[_], V[_], E](rule: Rule[F, V, E]) extends AnyVal
trait Tag[+F[_], +V[_], +E]

Types

type Base[+F[_], +V[_], +E] = Any { type __Rule__; }
type Type[+F[_], +V[_], +E] <: Base[F, V, E] & Tag[F, V, E]

Value members

Concrete methods

def and[F[_], V[_], E](ra: Rule[F, V, E], rb: Rule[F, V, E])(implicit F: Effect[F], V: Validated[V]): Rule[F, V, E]

Combines two Rule[F, V, E]'s using logical AND. Short-circuits if Validated.strategy is jap.fields.typeclass.FailFastStrategy

Combines two Rule[F, V, E]'s using logical AND. Short-circuits if Validated.strategy is jap.fields.typeclass.FailFastStrategy

def andAll[F[_] : Effect, V[_] : Validated, E](rules: List[Rule[F, V, E]]): Rule[F, V, E]

Combines all rules using AND

Combines all rules using AND

def apply[F[_], V[_], E](effect: F[V[E]]): Rule[F, V, E]

Same as Rule.wrap

Same as Rule.wrap

def assert[F[_], V[_], E](e: => E)(test: => Boolean)(implicit F: Effect[F], V: Validated[V]): Rule[F, V, E]

Asserts that if test pass else returns provided E

Asserts that if test pass else returns provided E

def assertF[F[_], V[_], E](e: => E)(test: => F[Boolean])(implicit F: Effect[F], V: Validated[V]): Rule[F, V, E]

Asserts that if test pass else returns provided E

Asserts that if test pass else returns provided E

def defer[F[_], V[_], E](rule: => Rule[F, V, E])(implicit F: Effect[F]): Rule[F, V, E]

Defers Rule

Defers Rule

def effect[F[_], V[_], E](effect: => F[V[E]])(implicit F: Effect[F]): Rule[F, V, E]

Lazily converts an F[V[E]] to a Rule[F, VR, E]

Lazily converts an F[V[E]] to a Rule[F, VR, E]

def ensure[F[_], V[_], E](v: => V[E])(test: => Boolean)(implicit F: Effect[F], V: Validated[V]): Rule[F, V, E]

Ensures that if test pass else returns provided V[E]

Ensures that if test pass else returns provided V[E]

def ensureF[F[_], V[_], E](v: => V[E])(test: => F[Boolean])(implicit F: Effect[F], V: Validated[V]): Rule[F, V, E]

Ensures that if test pass else returns provided V[E]

Ensures that if test pass else returns provided V[E]

def invalid[F[_], V[_], E](error: => E)(implicit F: Effect[F], V: Validated[V]): Rule[F, V, E]

Converts E to a Rule[F, V, E]

Converts E to a Rule[F, V, E]

def modify[F[_], V[_], E](rule: Rule[F, V, E])(f: V[E] => V[E])(implicit F: Effect[F]): Rule[F, V, E]

Modifies rule Validated value using f

Modifies rule Validated value using f

def modifyM[F[_], V[_], E](rule: Rule[F, V, E])(f: V[E] => Rule[F, V, E])(implicit F: Effect[F]): Rule[F, V, E]

Modifies rule Validated value using f

Modifies rule Validated value using f

def or[F[_], V[_], E](ra: Rule[F, V, E], rb: Rule[F, V, E])(implicit F: Effect[F], V: Validated[V]): Rule[F, V, E]

Combines two Rule[F, V, E]'s using logical OR. Short-circuits if first rule is valid

Combines two Rule[F, V, E]'s using logical OR. Short-circuits if first rule is valid

def orAll[F[_] : Effect, V[_] : Validated, E](rules: List[Rule[F, V, E]]): Rule[F, V, E]

Combines all rules using OR

Combines all rules using OR

def pure[F[_], V[_], E](validated: => V[E])(implicit F: Effect[F]): Rule[F, V, E]

Lazily converts an V[E] to Rule[F, VR, E]

Lazily converts an V[E] to Rule[F, VR, E]

def unwrap[F[_], V[_], E](rule: Rule[F, V, E]): F[V[E]]

Unwraps rule from tagged type

Unwraps rule from tagged type

def valid[F[_], V[_], E](implicit F: Effect[F], V: Validated[V]): Rule[F, V, E]

Returns always valid Rule[F, V, E]

Returns always valid Rule[F, V, E]

def when[F[_] : Effect, V[_] : Validated, E](test: => Boolean)(rule: => Rule[F, V, E]): Rule[F, V, E]

Applies rule only when test pass

Applies rule only when test pass

def whenF[F[_], V[_], E](test: => F[Boolean])(rule: => Rule[F, V, E])(implicit F: Effect[F], V: Validated[V]): Rule[F, V, E]

Applies rule only when test pass

Applies rule only when test pass

def wrap[F[_], V[_], E](effect: F[V[E]]): Rule[F, V, E]

Wraps rule into tagged type

Wraps rule into tagged type

Implicits

Implicits

final implicit def RuleOps[F[_], V[_], E](rule: Rule[F, V, E]): RuleOps[F, V, E]