Lucre-expr/de.sciss.lucre.expr/ExSeqOps

ExSeqOps

final class ExSeqOps[A](x: Ex[Seq[A]]) extends AnyVal
class AnyVal
trait Matchable
class Any

Value members

Concrete methods

def ++[B >: A](that: Ex[Seq[B]]): Ex[Seq[B]]

A concatenation of this sequence with that sequence

A concatenation of this sequence with that sequence

def +:[B >: A](elem: Ex[B]): Ex[Seq[B]]

A new sequence with the element prepended

A new sequence with the element prepended

def :+[B >: A](elem: Ex[B]): Ex[Seq[B]]

A new sequence with the element appended

A new sequence with the element appended

def appended[B >: A](elem: Ex[B]): Ex[Seq[B]]

A new sequence with the element appended

A new sequence with the element appended

def apply(index: Ex[Int])(implicit d: HasDefault[A]): Ex[A]

The element at a given index if the index is valid, otherwise the default value

The element at a given index if the index is valid, otherwise the default value

def applyOption(index: Ex[Int]): Ex[Option[A]]

The element at a given index if the index is valid

The element at a given index if the index is valid

def concat[B >: A](that: Ex[Seq[B]]): Ex[Seq[B]]

A concatenation of this sequence with that sequence

A concatenation of this sequence with that sequence

def contains(elem: Ex[A]): Ex[Boolean]

Whether this collection contains an element or not

Whether this collection contains an element or not

def count(p: Ex[A] => Ex[Boolean]): Ex[Int]
def diff(that: Ex[Seq[A]]): Ex[Seq[A]]

The multiset difference between this sequence and that sequence

The multiset difference between this sequence and that sequence

def differentiate(implicit num: Num[A]): Ex[Seq[A]]
def distinct: Ex[Seq[A]]

All the elements of this sequence ignoring the duplicates

All the elements of this sequence ignoring the duplicates

def drop(n: Ex[Int]): Ex[Seq[A]]

All elements except first n ones

All elements except first n ones

def dropRight(n: Ex[Int]): Ex[Seq[A]]

The rest of this sequence without its n last elements

The rest of this sequence without its n last elements

def dropWhile(p: Ex[A] => Ex[Boolean]): Ex[Seq[A]]
def endsWith(that: Ex[Seq[A]]): Ex[Boolean]

Tests whether this sequence ends with that sequence

Tests whether this sequence ends with that sequence

def exists(p: Ex[A] => Ex[Boolean]): Ex[Boolean]
def filter(p: Ex[A] => Ex[Boolean]): Ex[Seq[A]]
def filterNot(p: Ex[A] => Ex[Boolean]): Ex[Seq[A]]
def find(p: Ex[A] => Ex[Boolean]): Ex[Option[A]]
def findLast(p: Ex[A] => Ex[Boolean]): Ex[Option[A]]
def flatMap[B, To](f: Ex[A] => B)(implicit fm: CanFlatMap[Seq, B, To]): To
def foldLeft[B](z: Ex[B])(op: (Ex[B], Ex[A]) => Ex[B]): Ex[B]
def forall(p: Ex[A] => Ex[Boolean]): Ex[Boolean]
def grouped(size: Ex[Int]): Ex[Seq[Seq[A]]]

Partitions elements in fixed size sequences

Partitions elements in fixed size sequences

def head(implicit d: HasDefault[A]): Ex[A]

The first element if the sequence is non-empty, otherwise the default value

The first element if the sequence is non-empty, otherwise the default value

def headOption: Ex[Option[A]]

The first element if the sequence is non-empty

The first element if the sequence is non-empty

def indexOf(elem: Ex[A]): Ex[Int]

The index of the first occurrence of elem in this sequence, or -1 if not found

The index of the first occurrence of elem in this sequence, or -1 if not found

def indexOf(elem: Ex[A], from: Ex[Int]): Ex[Int]

The index of the first occurrence of elem at or after from in this sequence, or -1 if not found

The index of the first occurrence of elem at or after from in this sequence, or -1 if not found

def indexOfSlice(that: Ex[Seq[A]]): Ex[Int]

First index where this sequence contains that sequence as a slice, or -1 if not found

First index where this sequence contains that sequence as a slice, or -1 if not found

def indexOfSlice(that: Ex[Seq[A]], from: Ex[Int]): Ex[Int]

First index at or after from where this sequence contains that sequence as a slice, or -1 if not found

First index at or after from where this sequence contains that sequence as a slice, or -1 if not found

def indexWhere(p: Ex[A] => Ex[Boolean]): Ex[Int]
def indices: Ex[Seq[Int]]

Indices from zero until the size of this sequence

Indices from zero until the size of this sequence

def integrate(implicit num: Num[A]): Ex[Seq[A]]
def intersect(that: Ex[Seq[A]]): Ex[Seq[A]]

The multiset intersection between this sequence and that sequence

The multiset intersection between this sequence and that sequence

def isDefinedAt(index: Ex[Int]): Ex[Boolean]

Whether an index lies within this sequence

Whether an index lies within this sequence

def isEmpty: Ex[Boolean]
def last(implicit d: HasDefault[A]): Ex[A]

The last element if the sequence is non-empty, otherwise the default value

The last element if the sequence is non-empty, otherwise the default value

def lastIndexOf(elem: Ex[A]): Ex[Int]

The index of the last occurrence of elem in this sequence, or -1 if not found

The index of the last occurrence of elem in this sequence, or -1 if not found

def lastIndexOf(elem: Ex[A], end: Ex[Int]): Ex[Int]

The index of the last occurrence of elem at or before end in this sequence, or -1 if not found

The index of the last occurrence of elem at or before end in this sequence, or -1 if not found

def lastIndexOfSlice(that: Ex[Seq[A]]): Ex[Int]

Last index where this sequence contains that sequence as a slice, or -1 if not found

Last index where this sequence contains that sequence as a slice, or -1 if not found

def lastIndexOfSlice(that: Ex[Seq[A]], end: Ex[Int]): Ex[Int]

Last index at or before end where this sequence contains that sequence as a slice, or -1 if not found

Last index at or before end where this sequence contains that sequence as a slice, or -1 if not found

def lastOption: Ex[Option[A]]

The last element if the sequence is non-empty

The last element if the sequence is non-empty

def map[B, To](f: Ex[A] => B)(implicit m: CanMap[Seq, B, To]): To
def maxOption(implicit ord: ScalarOrd[A]): Ex[Option[A]]
def minOption(implicit ord: ScalarOrd[A]): Ex[Option[A]]
def mkString: Ex[String]
def mkString(sep: Ex[String]): Ex[String]
def mkString(start: Ex[String], sep: Ex[String], end: Ex[String]): Ex[String]
def nonEmpty: Ex[Boolean]
def padTo[B >: A](len: Ex[Int], elem: Ex[B]): Ex[Seq[B]]
def patch[B >: A](from: Ex[Int], other: Ex[Seq[B]], replaced: Ex[Int]): Ex[Seq[B]]
def permutations: Ex[Seq[Seq[A]]]
def prepended[B >: A](elem: Ex[B]): Ex[Seq[B]]
def product(implicit num: Num[A]): Ex[A]
def reverse: Ex[Seq[A]]
def sameElements[B >: A](that: Ex[Seq[B]]): Ex[Boolean]
def select[B](implicit bridge: Bridge[B], ev: Ex[Seq[A]] =:= Ex[Seq[Obj]]): Ex[Seq[B]]
def selectFirst[B](implicit bridge: Bridge[B], ev: Ex[Seq[A]] =:= Ex[Seq[Obj]]): Ex[Option[B]]
def size: Ex[Int]

The number of elements in the sequence

The number of elements in the sequence

def slice(from: Ex[Int], until: Ex[Int]): Ex[Seq[A]]
def sliding(size: Ex[Int], step: Ex[Int]): Ex[Seq[Seq[A]]]

Groups elements in fixed size blocks by passing a "sliding window" over them. Note that both size and step are automatically constraint to values of one and greater.

Groups elements in fixed size blocks by passing a "sliding window" over them. Note that both size and step are automatically constraint to values of one and greater.

def sorted(implicit ord: ScalarOrd[A]): Ex[Seq[A]]
def splitAt(n: Ex[Int]): Ex[(Seq[A], Seq[A])]
def startsWith(that: Ex[Seq[A]], offset: Ex[Int]): Ex[Boolean]

Tests whether this sequence starts with that sequence

Tests whether this sequence starts with that sequence

def sum(implicit num: Num[A]): Ex[A]
def take(n: Ex[Int]): Ex[Seq[A]]
def takeRight(n: Ex[Int]): Ex[Seq[A]]
def takeWhile(p: Ex[A] => Ex[Boolean]): Ex[Seq[A]]
def updated[B >: A](index: Ex[Int], elem: Ex[B]): Ex[Seq[B]]

A new sequence equal to this sequence with one single replaced elem at index. If the index lies outside the sequence, the original sequence is returned.

A new sequence equal to this sequence with one single replaced elem at index. If the index lies outside the sequence, the original sequence is returned.

def withFilter(p: Ex[A] => Ex[Boolean]): Ex[Seq[A]]
def zip[B](that: Ex[Seq[B]]): Ex[Seq[(A, B)]]
def zipWithIndex: Ex[Seq[(A, Int)]]