Packages

object Rule

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Rule
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Type Members

  1. type Base[F[_], V[_], +E] = Any { type __Rule__ }
  2. implicit final class RuleOps[F[_], V[_], E] extends AnyVal
  3. trait Tag[F[_], V[_], +E] extends Any
  4. abstract type Type[F[_], V[_], +E] <: Base[F[_], V[_], E] with Tag[F[_], V[_], E]

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. 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.

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

  5. def andAll[F[_], V[_], E](rules: List[Rule[F, V, E]])(implicit arg0: Effect[F], arg1: Validated[V]): Rule[F, V, E]

    Combines all rules using AND

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

    Same as Rule.wrap

    Same as Rule.wrap

    Annotations
    @inline()
  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()
  9. def defer[F[_], V[_], E](rule: => Rule[F, V, E])(implicit F: Effect[F]): Rule[F, V, E]

    Defers Rule

  10. 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]

  11. 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]

  12. 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]

  13. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  14. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  15. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  16. def fold[F[_], V[_], E, B](rule: Rule[F, V, E])(onInvalid: (V[E]) => B, onValid: => B)(implicit F: Effect[F], V: Validated[V]): F[B]

    Folds Rule[F, V, E] into F[B]

  17. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  18. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  19. 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]

  20. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  21. 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

  22. 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

  23. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  24. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  25. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  26. 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.

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

  27. def orAll[F[_], V[_], E](rules: List[Rule[F, V, E]])(implicit arg0: Effect[F], arg1: Validated[V]): Rule[F, V, E]

    Combines all rules using OR

  28. 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]

  29. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  30. def toString(): String
    Definition Classes
    AnyRef → Any
  31. def unwrap[F[_], V[_], E](rule: Rule[F, V, E]): F[V[E]]

    Unwraps rule from tagged type

    Unwraps rule from tagged type

    Annotations
    @inline()
  32. def valid[F[_], V[_], E](implicit F: Effect[F], V: Validated[V]): Rule[F, V, E]

    Returns always valid Rule[F, V, E]

  33. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  34. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  35. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  36. def when[F[_], V[_], E](test: => Boolean)(rule: => Rule[F, V, E])(implicit arg0: Effect[F], arg1: Validated[V]): Rule[F, V, E]

    Applies rule only when test pass

  37. 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

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

    Wraps rule into tagged type

    Wraps rule into tagged type

    Annotations
    @inline()

Inherited from AnyRef

Inherited from Any

Ungrouped