collection

Type Members

type Contains[U] = Not[Forall[Not[Equal[U]]]]

Predicate that checks if a Traversable contains a value equal to U.
final case class Count[PA, PC](pa: PA, pc: PC) extends Product with Serializable

Predicate that counts the number of elements in a Traversable which satisfy the predicate PA and passes the result to the numeric predicate PC.
final case class Empty() extends Product with Serializable

Predicate that checks if a Traversable is empty.
type Exists[P] = Not[Forall[Not[P]]]

Predicate that checks if the predicate P holds for some elements of a Traversable.
final case class Forall[P](p: P) extends Product with Serializable

Predicate that checks if the predicate P holds for all elements of a Traversable.
final case class Head[P](p: P) extends Product with Serializable

Predicate that checks if the predicate P holds for the first element of a Traversable.
final case class Index[N, P](n: N, p: P) extends Product with Serializable

Predicate that checks if the predicate P holds for the element at index N of a sequence.
final case class Init[P](p: P) extends Product with Serializable

Predicate that checks if the predicate P holds for all but the last element of a Traversable.
final case class Last[P](p: P) extends Product with Serializable

Predicate that checks if the predicate P holds for the last element of a Traversable.
type MaxSize[N] = Size[LessEqual[N]]

Predicate that checks if the size of a Traversable is less than or equal to N.
type MinSize[N] = Size[GreaterEqual[N]]

Predicate that checks if the size of a Traversable is greater than or equal to N.
type NonEmpty = Not[Empty]

Predicate that checks if a Traversable is not empty.
final case class Size[P](p: P) extends Product with Serializable

Predicate that checks if the size of a Traversable satisfies the predicate P.
final case class Tail[P](p: P) extends Product with Serializable

Predicate that checks if the predicate P holds for all but the first element of a Traversable.

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
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
implicit def countValidate[A, PA, RA, PC, RC, T](implicit va: Aux[A, PA, RA], vc: Aux[Int, PC, RC], ev: (T) ⇒ Traversable[A]): Aux[T, Count[PA, PC], Count[List[(va)#Res], (vc)#Res]]

Definition Classes
CollectionValidate
implicit def emptyValidate[T](implicit ev: (T) ⇒ Traversable[_]): Plain[T, Empty]

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

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

Definition Classes
AnyRef → Any
implicit def existsInference[A, B](implicit p1: ==>[A, B]): ==>[Exists[A], Exists[B]]

Definition Classes
CollectionInference
implicit def existsNonEmptyInference[P]: ==>[Exists[P], NonEmpty]

Definition Classes
CollectionInference
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
implicit def forallValidate[A, P, R, T[a] <: Traversable[a]](implicit v: Aux[A, P, R]): Aux[T[A], Forall[P], Forall[List[(v)#Res]]]

Definition Classes
CollectionValidate
implicit def forallValidateView[A, P, R, T](implicit v: Aux[A, P, R], ev: (T) ⇒ Traversable[A]): Aux[T, Forall[P], Forall[List[(v)#Res]]]

Definition Classes
CollectionValidate
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
implicit def headExistsInference[P]: ==>[Head[P], Exists[P]]

Definition Classes
CollectionInference
implicit def headInference[A, B](implicit p1: ==>[A, B]): ==>[Head[A], Head[B]]

Definition Classes
CollectionInference
implicit def headValidate[A, P, R, T[a] <: Traversable[a]](implicit v: Aux[A, P, R]): Aux[T[A], Head[P], Head[Option[(v)#Res]]]

Definition Classes
CollectionValidate
implicit def headValidateView[A, P, R, T](implicit v: Aux[A, P, R], ev: (T) ⇒ Traversable[A]): Aux[T, Head[P], Head[Option[(v)#Res]]]

Definition Classes
CollectionValidate
implicit def indexExistsInference[N, P]: ==>[Index[N, P], Exists[P]]

Definition Classes
CollectionInference
implicit def indexInference[N, A, B](implicit p1: ==>[A, B]): ==>[Index[N, A], Index[N, B]]

Definition Classes
CollectionInference
implicit def indexValidate[A, P, R, N <: Int, T](implicit v: Aux[A, P, R], ev: (T) ⇒ PartialFunction[Int, A], wn: Aux[N]): Aux[T, Index[N, P], Index[N, Option[(v)#Res]]]

Definition Classes
CollectionValidate
implicit def initValidate[A, P, R, T[a] <: Traversable[a]](implicit v: Aux[A, P, R]): Aux[T[A], Init[P], Init[List[(v)#Res]]]

Definition Classes
CollectionValidate
implicit def initValidateView[A, P, R, T](implicit v: Aux[A, P, R], ev: (T) ⇒ Traversable[A]): Aux[T, Init[P], Init[List[(v)#Res]]]

Definition Classes
CollectionValidate
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
implicit def lastExistsInference[P]: ==>[Last[P], Exists[P]]

Definition Classes
CollectionInference
implicit def lastInference[A, B](implicit p1: ==>[A, B]): ==>[Last[A], Last[B]]

Definition Classes
CollectionInference
implicit def lastValidate[A, P, R, T[a] <: Traversable[a]](implicit v: Aux[A, P, R]): Aux[T[A], Last[P], Last[Option[(v)#Res]]]

Definition Classes
CollectionValidate
implicit def lastValidateView[A, P, R, T](implicit v: Aux[A, P, R], ev: (T) ⇒ Traversable[A]): Aux[T, Last[P], Last[Option[(v)#Res]]]

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

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
implicit def sizeInference[A, B](implicit p1: ==>[A, B]): ==>[Size[A], Size[B]]

Definition Classes
CollectionInference
implicit def sizeValidate[T, P, RP](implicit v: Aux[Int, P, RP], ev: (T) ⇒ Traversable[_]): Aux[T, Size[P], Size[(v)#Res]]

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

Definition Classes
AnyRef
implicit def tailValidate[A, P, R, T[a] <: Traversable[a]](implicit v: Aux[A, P, R]): Aux[T[A], Tail[P], Tail[List[(v)#Res]]]

Definition Classes
CollectionValidate
implicit def tailValidateView[A, P, R, T](implicit v: Aux[A, P, R], ev: (T) ⇒ Traversable[A]): Aux[T, Tail[P], Tail[List[(v)#Res]]]

Definition Classes
CollectionValidate
def toString(): String

Definition Classes
AnyRef → Any
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( ... )

Related Doc: package refined

object collection extends CollectionValidate with CollectionInference

Type Members

type Contains[U] = Not[Forall[Not[Equal[U]]]]

final case class Count[PA, PC](pa: PA, pc: PC) extends Product with Serializable

final case class Empty() extends Product with Serializable

type Exists[P] = Not[Forall[Not[P]]]

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

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

final case class Index[N, P](n: N, p: P) extends Product with Serializable

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

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

type MaxSize[N] = Size[LessEqual[N]]

type MinSize[N] = Size[GreaterEqual[N]]

type NonEmpty = Not[Empty]

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

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

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

implicit def countValidate[A, PA, RA, PC, RC, T](implicit va: Aux[A, PA, RA], vc: Aux[Int, PC, RC], ev: (T) ⇒ Traversable[A]): Aux[T, Count[PA, PC], Count[List[(va)#Res], (vc)#Res]]

implicit def emptyValidate[T](implicit ev: (T) ⇒ Traversable[_]): Plain[T, Empty]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

implicit def existsInference[A, B](implicit p1: ==>[A, B]): ==>[Exists[A], Exists[B]]

implicit def existsNonEmptyInference[P]: ==>[Exists[P], NonEmpty]

def finalize(): Unit

implicit def forallValidate[A, P, R, T[a] <: Traversable[a]](implicit v: Aux[A, P, R]): Aux[T[A], Forall[P], Forall[List[(v)#Res]]]

implicit def forallValidateView[A, P, R, T](implicit v: Aux[A, P, R], ev: (T) ⇒ Traversable[A]): Aux[T, Forall[P], Forall[List[(v)#Res]]]

final def getClass(): Class[_]

def hashCode(): Int

implicit def headExistsInference[P]: ==>[Head[P], Exists[P]]

implicit def headInference[A, B](implicit p1: ==>[A, B]): ==>[Head[A], Head[B]]

implicit def headValidate[A, P, R, T[a] <: Traversable[a]](implicit v: Aux[A, P, R]): Aux[T[A], Head[P], Head[Option[(v)#Res]]]

implicit def headValidateView[A, P, R, T](implicit v: Aux[A, P, R], ev: (T) ⇒ Traversable[A]): Aux[T, Head[P], Head[Option[(v)#Res]]]

implicit def indexExistsInference[N, P]: ==>[Index[N, P], Exists[P]]

implicit def indexInference[N, A, B](implicit p1: ==>[A, B]): ==>[Index[N, A], Index[N, B]]

implicit def indexValidate[A, P, R, N <: Int, T](implicit v: Aux[A, P, R], ev: (T) ⇒ PartialFunction[Int, A], wn: Aux[N]): Aux[T, Index[N, P], Index[N, Option[(v)#Res]]]

implicit def initValidate[A, P, R, T[a] <: Traversable[a]](implicit v: Aux[A, P, R]): Aux[T[A], Init[P], Init[List[(v)#Res]]]

implicit def initValidateView[A, P, R, T](implicit v: Aux[A, P, R], ev: (T) ⇒ Traversable[A]): Aux[T, Init[P], Init[List[(v)#Res]]]

final def isInstanceOf[T0]: Boolean

implicit def lastExistsInference[P]: ==>[Last[P], Exists[P]]

implicit def lastInference[A, B](implicit p1: ==>[A, B]): ==>[Last[A], Last[B]]

implicit def lastValidate[A, P, R, T[a] <: Traversable[a]](implicit v: Aux[A, P, R]): Aux[T[A], Last[P], Last[Option[(v)#Res]]]

implicit def lastValidateView[A, P, R, T](implicit v: Aux[A, P, R], ev: (T) ⇒ Traversable[A]): Aux[T, Last[P], Last[Option[(v)#Res]]]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

implicit def sizeInference[A, B](implicit p1: ==>[A, B]): ==>[Size[A], Size[B]]

implicit def sizeValidate[T, P, RP](implicit v: Aux[Int, P, RP], ev: (T) ⇒ Traversable[_]): Aux[T, Size[P], Size[(v)#Res]]

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

implicit def tailValidate[A, P, R, T[a] <: Traversable[a]](implicit v: Aux[A, P, R]): Aux[T[A], Tail[P], Tail[List[(v)#Res]]]

implicit def tailValidateView[A, P, R, T](implicit v: Aux[A, P, R], ev: (T) ⇒ Traversable[A]): Aux[T, Tail[P], Tail[List[(v)#Res]]]

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from CollectionInference

Inherited from CollectionValidate

Inherited from AnyRef

Inherited from Any

Ungrouped