Rule

abstract def apply(value: A): Checked[B]

Performs validation on A

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def andThen[C](that: Rule[B, C]): Rule[A, C]

final def asInstanceOf[T0]: T0

def at[P, S, T](prefix: P, lens: PLens[S, T, A, B])(implicit arg0: PathPrefix[P]): Rule[S, T]

def clone(): AnyRef

def composeLens[S, T](lens: PLens[S, T, A, B]): Rule[S, T]

def contramap[C](func: (C) ⇒ A): Rule[C, B]

def contramapPath[C, D](path: D)(func: (C) ⇒ A)(implicit arg0: PathPrefix[D]): Rule[C, B]

def emap[C](func: (B) ⇒ Checked[C]): Rule[A, C]

Maps the result type with the potential for a failure to occur.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def flatMap[C](func: (B) ⇒ Rule[A, C]): Rule[A, C]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def kleisli: Kleisli[Checked, A, B]

def map[C](func: (B) ⇒ C): Rule[A, C]

def mapEachMessage(func: (Message) ⇒ Message): Rule[A, B]

def mapMessages(func: (Messages) ⇒ Messages): Rule[A, B]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def opt: Rule[Option[A], Option[B]]

def prefix[P](prefix: P)(implicit arg0: PathPrefix[P]): Rule[A, B]

def recover(func: (Messages) ⇒ Checked[B]): Rule[A, B]

def req: Rule[Option[A], B]

def seq[S[_]](implicit arg0: Traverse[S]): Rule[S[A], S[B]]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def zip[C](that: Rule[A, C]): Rule[A, (B, C)]