aptus-core
API
Generated with
aptus-core/aptus/aptus.aptmisc/Items

Items

aptus.aptmisc.Items
trait Items[$Items <: Items[_, _], $Item] extends HasConst[Seq[$Item], $Items]

Attributes

Graph
Supertypes
trait HasConst[Seq[$Item], $Items]
class Object
trait Matchable
class Any

Members list

Type members

Types

type Item = $Item
type Self = $Items

Value members

Abstract methods

def values: Seq[$Item]

Concrete methods

def append(datum: $Item): $Items
def append(data: Seq[$Item]): $Items
def append(datum: $Item, f: (Seq[$Item]) => Seq[$Item]): $Items
def append(data: Seq[$Item], f: (Seq[$Item]) => Seq[$Item]): $Items
def contains(value: $Item): Boolean
def diff(that: Self): Self
def distinct: $Items
def drop(n: Int): $Items
def dropRight(n: Int): $Items
def dropWhile(p: $Item => Boolean): $Items
def endoFlatMap(f: $Item => Iterable[$Item]): $Items
def endoMap(f: $Item => $Item): $Items
def endsWith(that: $Items): Boolean
def exists(p: $Item => Boolean): Boolean
def exoFlatMap[T](f: $Item => Iterable[T]): Seq[T]
def exoMap[T](f: $Item => T): Seq[T]
def filter(p: $Item => Boolean): $Items
def filterBy[B](f: $Item => B)(p: B => Boolean): $Items
def filterByNot[B](f: $Item => B)(p: B => Boolean): $Items
def filterContainsAnyOf(set: Set[$Item]): $Items
def filterContainsAnyOf(seq: Seq[$Item]): $Items
def filterNot(p: $Item => Boolean): $Items
def filterNotContainsAnyOf(set: Set[$Item]): $Items
def filterNotContainsAnyOf(seq: Seq[$Item]): $Items
def find(p: $Item => Boolean): Option[$Item]
def flatMap[T](f: $Item => Iterable[T]): Seq[T]
def forall(p: $Item => Boolean): Boolean
def force: Force[$Item]
def foreach[U](f: $Item => U): Unit
def grouping(size: Int): Iterator[Seq[$Item]]
def head: $Item
def headOption: Option[$Item]
def ifEmptyThenError(msg: String): $Items
def init: $Items
def initOption: Option[$Items]
def intersect(that: Self): Self
def isEmpty: Boolean
def last: $Item
def lastOption: Option[$Item]
def map[T](f: $Item => T): Seq[T]
def mapUnderlyingValues(f: (Seq[$Item]) => Seq[$Item]): $Items
def matchingIndex(target: Index): $Item
def matchingIndices(targets: Set[Index]): $Items
def merge(that: $Items): $Items
def merge(that: $Items, f: (Seq[$Item]) => Seq[$Item]): $Items
def nonEmpty: Boolean
def partition(p: $Item => Boolean): ($Items, $Items)
def prepend(datum: $Item): $Items
def prepend(data: Seq[$Item]): $Items
def prepend(datum: $Item, f: (Seq[$Item]) => Seq[$Item]): $Items
def prepend(data: Seq[$Item], f: (Seq[$Item]) => Seq[$Item]): $Items
def size: Int
def sliding(size: Int): Iterator[Seq[$Item]]
def sortBy[T : Ordering](f: $Item => T): $Items
def sorted(implicit ord: Ordering[$Item]): $Items
def span(p: $Item => Boolean): ($Items, $Items)
def startsWith(that: $Items): Boolean
def tail: $Items
def tailOption: Option[$Items]
def take(n: Int): $Items
def takeRight(n: Int): $Items
def takeUntil(p: $Item => Boolean): $Items
def takeWhile(p: $Item => Boolean): $Items
def zipWithIndex: Seq[($Item, Index)]

Inherited methods

protected def const: Seq[$Item] => $Items

Attributes

Inherited from:
HasConst
Generated with