boolean

Type Members

final case class AllOf[PS](ps: PS) extends Product with Serializable

Conjunction of all predicates in PS.
final case class And[A, B](a: A, b: B) extends Product with Serializable

Conjunction of the predicates A and B.
final case class AnyOf[PS](ps: PS) extends Product with Serializable

Disjunction of all predicates in PS.
final case class False() extends Product with Serializable

Constant predicate that is always false.
type Nand[A, B] = Not[And[A, B]]

Negated conjunction of the predicates A and B.
type Nor[A, B] = Not[Or[A, B]]

Negated disjunction of the predicates A and B.
final case class Not[P](p: P) extends Product with Serializable

Negation of the predicate P.
final case class OneOf[PS](ps: PS) extends Product with Serializable

Exclusive disjunction of all predicates in PS.
final case class Or[A, B](a: A, b: B) extends Product with Serializable

Disjunction of the predicates A and B.
final case class True() extends Product with Serializable

Constant predicate that is always true.
final case class Xor[A, B](a: A, b: B) extends Product with Serializable

Exclusive disjunction of the predicates A and B.

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
implicit def allOfHConsValidate[T, PH, RH, PT <: HList, RT <: HList](implicit vh: Aux[T, PH, RH], vt: Aux[T, AllOf[PT], AllOf[RT]]): Aux[T, AllOf[::[PH, PT]], AllOf[::[(vh)#Res, RT]]]

Definition Classes
BooleanValidate
implicit def allOfHNilValidate[T]: Plain[T, AllOf[HNil]]

Definition Classes
BooleanValidate
implicit def andValidate[T, A, RA, B, RB](implicit va: Aux[T, A, RA], vb: Aux[T, B, RB]): Aux[T, And[A, B], And[(va)#Res, (vb)#Res]]

Definition Classes
BooleanValidate
implicit def anyOfHConsValidate[T, PH, RH, PT <: HList, RT <: HList](implicit vh: Aux[T, PH, RH], vt: Aux[T, AnyOf[PT], AnyOf[RT]]): Aux[T, AnyOf[::[PH, PT]], AnyOf[::[(vh)#Res, RT]]]

Definition Classes
BooleanValidate
implicit def anyOfHNilValidate[T]: Plain[T, AnyOf[HNil]]

Definition Classes
BooleanValidate
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
implicit def conjunctionAssociativity[A, B, C]: ==>[And[And[A, B], C], And[A, And[B, C]]]

Definition Classes
BooleanInference0
implicit def conjunctionCommutativity[A, B]: ==>[And[A, B], And[B, A]]

Definition Classes
BooleanInference0
implicit def conjunctionEliminationL[A, B, C](implicit p1: ==>[A, C]): ==>[And[A, B], C]

Definition Classes
BooleanInference2
implicit def conjunctionEliminationR[A, B, C](implicit p1: ==>[B, C]): ==>[And[A, B], C]

Definition Classes
BooleanInference0
implicit def deMorgansLaw1[A, B]: ==>[Not[And[A, B]], Or[Not[A], Not[B]]]

Definition Classes
BooleanInference0
implicit def deMorgansLaw2[A, B]: ==>[Not[Or[A, B]], And[Not[A], Not[B]]]

Definition Classes
BooleanInference0
implicit def disjunctionAssociativity[A, B, C]: ==>[Or[Or[A, B], C], Or[A, Or[B, C]]]

Definition Classes
BooleanInference0
implicit def disjunctionCommutativity[A, B]: ==>[Or[A, B], Or[B, A]]

Definition Classes
BooleanInference0
implicit def disjunctionIntroductionL[A, B]: ==>[A, Or[A, B]]

Definition Classes
BooleanInference0
implicit def disjunctionIntroductionR[A, B]: ==>[B, Or[A, B]]

Definition Classes
BooleanInference0
implicit def doubleNegationElimination[A, B](implicit p1: ==>[A, B]): ==>[Not[Not[A]], B]

Definition Classes
BooleanInference0
implicit def doubleNegationIntroduction[A, B](implicit p1: ==>[A, B]): ==>[A, Not[Not[B]]]

Definition Classes
BooleanInference0
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
implicit def falseValidate[T]: Plain[T, False]

Definition Classes
BooleanValidate
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
implicit def hypotheticalSyllogism[A, B, C](implicit p1: ==>[A, B], p2: ==>[B, C]): ==>[A, C]

Definition Classes
BooleanInference2
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
implicit def minimalTautology[A]: ==>[A, A]

Definition Classes
BooleanInference0
implicit def modusTollens[A, B](implicit p1: ==>[A, B]): ==>[Not[B], Not[A]]

Definition Classes
BooleanInference1
implicit def nandCommutativity[A, B]: ==>[Nand[A, B], Nand[B, A]]

Definition Classes
BooleanInference0
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
implicit def norCommutativity[A, B]: ==>[Nor[A, B], Nor[B, A]]

Definition Classes
BooleanInference0
implicit def notValidate[T, P, R](implicit v: Aux[T, P, R]): Aux[T, Not[P], Not[(v)#Res]]

Definition Classes
BooleanValidate
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
implicit def oneOfHConsValidate[T, PH, RH, PT <: HList, RT <: HList](implicit vh: Aux[T, PH, RH], vt: Aux[T, OneOf[PT], OneOf[RT]], toList: ToList[RT, Result[_]]): Aux[T, OneOf[::[PH, PT]], OneOf[::[(vh)#Res, RT]]]

Definition Classes
BooleanValidate
implicit def oneOfHNilValidate[T]: Plain[T, OneOf[HNil]]

Definition Classes
BooleanValidate
implicit def orValidate[T, A, RA, B, RB](implicit va: Aux[T, A, RA], vb: Aux[T, B, RB]): Aux[T, Or[A, B], Or[(va)#Res, (vb)#Res]]

Definition Classes
BooleanValidate
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
implicit def trueValidate[T]: Plain[T, True]

Definition Classes
BooleanValidate
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
implicit def xorCommutativity[A, B]: ==>[Xor[A, B], Xor[B, A]]

Definition Classes
BooleanInference0
implicit def xorValidate[T, A, RA, B, RB](implicit va: Aux[T, A, RA], vb: Aux[T, B, RB]): Aux[T, Xor[A, B], Xor[(va)#Res, (vb)#Res]]

Definition Classes
BooleanValidate

Related Doc: package refined

object boolean extends BooleanValidate with BooleanInference0

Type Members

final case class AllOf[PS](ps: PS) extends Product with Serializable

final case class And[A, B](a: A, b: B) extends Product with Serializable

final case class AnyOf[PS](ps: PS) extends Product with Serializable

final case class False() extends Product with Serializable

type Nand[A, B] = Not[And[A, B]]

type Nor[A, B] = Not[Or[A, B]]

final case class Not[P](p: P) extends Product with Serializable

final case class OneOf[PS](ps: PS) extends Product with Serializable

final case class Or[A, B](a: A, b: B) extends Product with Serializable

final case class True() extends Product with Serializable

final case class Xor[A, B](a: A, b: B) extends Product with Serializable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

implicit def allOfHConsValidate[T, PH, RH, PT <: HList, RT <: HList](implicit vh: Aux[T, PH, RH], vt: Aux[T, AllOf[PT], AllOf[RT]]): Aux[T, AllOf[::[PH, PT]], AllOf[::[(vh)#Res, RT]]]

implicit def allOfHNilValidate[T]: Plain[T, AllOf[HNil]]

implicit def andValidate[T, A, RA, B, RB](implicit va: Aux[T, A, RA], vb: Aux[T, B, RB]): Aux[T, And[A, B], And[(va)#Res, (vb)#Res]]

implicit def anyOfHConsValidate[T, PH, RH, PT <: HList, RT <: HList](implicit vh: Aux[T, PH, RH], vt: Aux[T, AnyOf[PT], AnyOf[RT]]): Aux[T, AnyOf[::[PH, PT]], AnyOf[::[(vh)#Res, RT]]]

implicit def anyOfHNilValidate[T]: Plain[T, AnyOf[HNil]]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

implicit def conjunctionAssociativity[A, B, C]: ==>[And[And[A, B], C], And[A, And[B, C]]]

implicit def conjunctionCommutativity[A, B]: ==>[And[A, B], And[B, A]]

implicit def conjunctionEliminationL[A, B, C](implicit p1: ==>[A, C]): ==>[And[A, B], C]

implicit def conjunctionEliminationR[A, B, C](implicit p1: ==>[B, C]): ==>[And[A, B], C]

implicit def deMorgansLaw1[A, B]: ==>[Not[And[A, B]], Or[Not[A], Not[B]]]

implicit def deMorgansLaw2[A, B]: ==>[Not[Or[A, B]], And[Not[A], Not[B]]]

implicit def disjunctionAssociativity[A, B, C]: ==>[Or[Or[A, B], C], Or[A, Or[B, C]]]

implicit def disjunctionCommutativity[A, B]: ==>[Or[A, B], Or[B, A]]

implicit def disjunctionIntroductionL[A, B]: ==>[A, Or[A, B]]

implicit def disjunctionIntroductionR[A, B]: ==>[B, Or[A, B]]

implicit def doubleNegationElimination[A, B](implicit p1: ==>[A, B]): ==>[Not[Not[A]], B]

implicit def doubleNegationIntroduction[A, B](implicit p1: ==>[A, B]): ==>[A, Not[Not[B]]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

implicit def falseValidate[T]: Plain[T, False]

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

implicit def hypotheticalSyllogism[A, B, C](implicit p1: ==>[A, B], p2: ==>[B, C]): ==>[A, C]

final def isInstanceOf[T0]: Boolean

implicit def minimalTautology[A]: ==>[A, A]

implicit def modusTollens[A, B](implicit p1: ==>[A, B]): ==>[Not[B], Not[A]]

implicit def nandCommutativity[A, B]: ==>[Nand[A, B], Nand[B, A]]

final def ne(arg0: AnyRef): Boolean

implicit def norCommutativity[A, B]: ==>[Nor[A, B], Nor[B, A]]

implicit def notValidate[T, P, R](implicit v: Aux[T, P, R]): Aux[T, Not[P], Not[(v)#Res]]

final def notify(): Unit

final def notifyAll(): Unit

implicit def oneOfHConsValidate[T, PH, RH, PT <: HList, RT <: HList](implicit vh: Aux[T, PH, RH], vt: Aux[T, OneOf[PT], OneOf[RT]], toList: ToList[RT, Result[_]]): Aux[T, OneOf[::[PH, PT]], OneOf[::[(vh)#Res, RT]]]

implicit def oneOfHNilValidate[T]: Plain[T, OneOf[HNil]]

implicit def orValidate[T, A, RA, B, RB](implicit va: Aux[T, A, RA], vb: Aux[T, B, RB]): Aux[T, Or[A, B], Or[(va)#Res, (vb)#Res]]

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

def toString(): String

implicit def trueValidate[T]: Plain[T, True]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

implicit def xorCommutativity[A, B]: ==>[Xor[A, B], Xor[B, A]]

implicit def xorValidate[T, A, RA, B, RB](implicit va: Aux[T, A, RA], vb: Aux[T, B, RB]): Aux[T, Xor[A, B], Xor[(va)#Res, (vb)#Res]]

Inherited from BooleanInference0

Inherited from BooleanInference1

Inherited from BooleanInference2

Inherited from BooleanValidate

Inherited from AnyRef

Inherited from Any

Ungrouped