Fields/jap.fields/Rule

Rule

object Rule
Source:
Rule.scala
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
Source:
Rule.scala
trait Tag[+F[_], +V[_], +E]
Source:
Rule.scala

Types

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

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

Source:
Rule.scala
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

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

Same as Rule.wrap

Same as Rule.wrap

Source:
Rule.scala
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

Source:
Rule.scala
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

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

Defers Rule

Defers Rule

Source:
Rule.scala
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]

Source:
Rule.scala
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]

Source:
Rule.scala
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]

Source:
Rule.scala
def flatten[F[_], V[_], E](rule: => F[Rule[F, V, E]])(implicit F: Effect[F]): Rule[F, V, E]

Flattens Effect with Rule

Flattens Effect with Rule

Source:
Rule.scala
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]

Source:
Rule.scala
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

Source:
Rule.scala
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

Source:
Rule.scala
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

Source:
Rule.scala
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

Source:
Rule.scala
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]

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

Unwraps rule from tagged type

Unwraps rule from tagged type

Source:
Rule.scala
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]

Source:
Rule.scala
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

Source:
Rule.scala
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

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

Wraps rule into tagged type

Wraps rule into tagged type

Source:
Rule.scala

Implicits

Implicits

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