collection

Type Members

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

Predicate that checks if a TraversableOnce contains a value equal to U.
trait Count[PA, PC] extends AnyRef

Predicate that counts the number of elements in a TraversableOnce which satisfy the predicate PA and passes the result to the numeric predicate PC.
trait Empty extends AnyRef

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

Predicate that checks if the predicate P holds for some elements of a TraversableOnce.
trait Forall[P] extends AnyRef

Predicate that checks if the predicate P holds for all elements of a TraversableOnce.
trait Head[P] extends AnyRef

Predicate that checks if the predicate P holds for the first element of a Traversable.
trait Index[N, P] extends AnyRef

Predicate that checks if the predicate P holds for the element at index N of a sequence.
trait Last[P] extends AnyRef

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 TraversableOnce is less than or equal to N.
type MinSize[N] = Size[GreaterEqual[N]]

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

Predicate that checks if a TraversableOnce is not empty.
trait Size[P] extends AnyRef

Predicate that checks if the size of a TraversableOnce satisfies the predicate P.

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 countPredicate[PA, PC, A, T](implicit pa: Predicate[PA, A], pc: Predicate[PC, Int], ev: (T) ⇒ TraversableOnce[A]): Predicate[Count[PA, PC], T]

Definition Classes
CollectionPredicates
implicit def emptyPredicate[T](implicit ev: (T) ⇒ TraversableOnce[_]): Predicate[Empty, T]

Definition Classes
CollectionPredicates
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
CollectionInferenceRules
implicit def existsNonEmptyInference[P]: ==>[Exists[P], NonEmpty]

Definition Classes
CollectionInferenceRules
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
implicit def forallPredicate[P, A, T[A] <: TraversableOnce[A]](implicit p: Predicate[P, A]): Predicate[Forall[P], T[A]]

Definition Classes
CollectionPredicates
implicit def forallPredicateView[P, A, T](implicit p: Predicate[P, A], ev: (T) ⇒ TraversableOnce[A]): Predicate[Forall[P], T]

Definition Classes
CollectionPredicates
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
CollectionInferenceRules
implicit def headInference[A, B](implicit p1: ==>[A, B]): ==>[Head[A], Head[B]]

Definition Classes
CollectionInferenceRules
implicit def headPredicate[P, A, T[A] <: Traversable[A]](implicit p: Predicate[P, A]): Predicate[Head[P], T[A]]

Definition Classes
CollectionPredicates
implicit def headPredicateView[P, A, T](implicit p: Predicate[P, A], ev: (T) ⇒ Traversable[A]): Predicate[Head[P], T]

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

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

Definition Classes
CollectionInferenceRules
implicit def indexPredicate[N <: Int, P, A, T](implicit p: Predicate[P, A], ev: (T) ⇒ PartialFunction[Int, A], wn: Aux[N]): Predicate[Index[N, P], T]

Definition Classes
CollectionPredicates
final def isInstanceOf[T0]: Boolean

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

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

Definition Classes
CollectionInferenceRules
implicit def lastPredicate[P, A, T[A] <: Traversable[A]](implicit p: Predicate[P, A]): Predicate[Last[P], T[A]]

Definition Classes
CollectionPredicates
implicit def lastPredicateView[P, A, T](implicit p: Predicate[P, A], ev: (T) ⇒ Traversable[A]): Predicate[Last[P], T]

Definition Classes
CollectionPredicates
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
CollectionInferenceRules
implicit def sizePredicate[P, T](implicit p: Predicate[P, Int], ev: (T) ⇒ TraversableOnce[_]): Predicate[Size[P], T]

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

Definition Classes
AnyRef
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 CollectionPredicates with CollectionInferenceRules

Type Members

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

trait Count[PA, PC] extends AnyRef

trait Empty extends AnyRef

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

trait Forall[P] extends AnyRef

trait Head[P] extends AnyRef

trait Index[N, P] extends AnyRef

trait Last[P] extends AnyRef

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

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

type NonEmpty = Not[Empty]

trait Size[P] extends AnyRef

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 countPredicate[PA, PC, A, T](implicit pa: Predicate[PA, A], pc: Predicate[PC, Int], ev: (T) ⇒ TraversableOnce[A]): Predicate[Count[PA, PC], T]

implicit def emptyPredicate[T](implicit ev: (T) ⇒ TraversableOnce[_]): Predicate[Empty, T]

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 forallPredicate[P, A, T[A] <: TraversableOnce[A]](implicit p: Predicate[P, A]): Predicate[Forall[P], T[A]]

implicit def forallPredicateView[P, A, T](implicit p: Predicate[P, A], ev: (T) ⇒ TraversableOnce[A]): Predicate[Forall[P], T]

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 headPredicate[P, A, T[A] <: Traversable[A]](implicit p: Predicate[P, A]): Predicate[Head[P], T[A]]

implicit def headPredicateView[P, A, T](implicit p: Predicate[P, A], ev: (T) ⇒ Traversable[A]): Predicate[Head[P], T]

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 indexPredicate[N <: Int, P, A, T](implicit p: Predicate[P, A], ev: (T) ⇒ PartialFunction[Int, A], wn: Aux[N]): Predicate[Index[N, P], T]

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 lastPredicate[P, A, T[A] <: Traversable[A]](implicit p: Predicate[P, A]): Predicate[Last[P], T[A]]

implicit def lastPredicateView[P, A, T](implicit p: Predicate[P, A], ev: (T) ⇒ Traversable[A]): Predicate[Last[P], T]

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 sizePredicate[P, T](implicit p: Predicate[P, Int], ev: (T) ⇒ TraversableOnce[_]): Predicate[Size[P], T]

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

Inherited from CollectionInferenceRules

Inherited from CollectionPredicates

Inherited from AnyRef

Inherited from Any

Ungrouped