Value Members

1.  final def !=(arg0: Any): Boolean

   Definition Classes

   Any

2.  final def ##: Int

   Definition Classes

   Any

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

   A concatenation of this sequence with that sequence

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

   A new sequence with the element prepended

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

   A new sequence with the element appended

6.  final def ==(arg0: Any): Boolean

   Definition Classes

   Any

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

   A new sequence with the element appended

8.  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

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

   The element at a given index if the index is valid

10.  final def asInstanceOf[T0]: T0

    Definition Classes

    Any

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

    A concatenation of this sequence with that sequence

12.  def contains(elem: Ex[A]): Ex[Boolean]

    Whether this collection contains an element or not

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

    The multiset difference between this sequence and that sequence

15.  def differentiate(implicit num: Num[A]): Ex[Seq[A]]
16.  def distinct: Ex[Seq[A]]

    All the elements of this sequence ignoring the duplicates

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

    All elements except first n ones

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

    The rest of this sequence without its n last elements

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

    Tests whether this sequence ends with that sequence

21.  def exists(p: (Ex[A]) => Ex[Boolean]): Ex[Boolean]
22.  def filter(p: (Ex[A]) => Ex[Boolean]): Ex[Seq[A]]
23.  def filterNot(p: (Ex[A]) => Ex[Boolean]): Ex[Seq[A]]
24.  def find(p: (Ex[A]) => Ex[Boolean]): Ex[Option[A]]
25.  def findLast(p: (Ex[A]) => Ex[Boolean]): Ex[Option[A]]
26.  def flatMap[B, To](f: (Ex[A]) => B)(implicit fm: CanFlatMap[Seq, B, To]): To
27.  def foldLeft[B](z: Ex[B])(op: (Ex[B], Ex[A]) => Ex[B]): Ex[B]
28.  def forall(p: (Ex[A]) => Ex[Boolean]): Ex[Boolean]
29.  def getClass(): Class[_ <: AnyVal]

    Definition Classes

    AnyVal → Any

30.  def grouped(size: Ex[Int]): Ex[Seq[Seq[A]]]

    Partitions elements in fixed size sequences

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

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

32.  def headOption: Ex[Option[A]]

    The first element if the sequence is non-empty

33.  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

34.  def indexOf(elem: Ex[A]): Ex[Int]

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

35.  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

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

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

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

    Indices from zero until the size of this sequence

39.  def integrate(implicit num: Num[A]): Ex[Seq[A]]
40.  def intersect(that: Ex[Seq[A]]): Ex[Seq[A]]

    The multiset intersection between this sequence and that sequence

41.  def isDefinedAt(index: Ex[Int]): Ex[Boolean]

    Whether an index lies within this sequence

42.  def isEmpty: Ex[Boolean]
43.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

44.  def last(implicit d: HasDefault[A]): Ex[A]

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

45.  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

46.  def lastIndexOf(elem: Ex[A]): Ex[Int]

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

47.  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

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

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

49.  def lastOption: Ex[Option[A]]

    The last element if the sequence is non-empty

50.  def map[B, To](f: (Ex[A]) => B)(implicit m: CanMap[Seq, B, To]): To
51.  def maxOption(implicit ord: ScalarOrd[A]): Ex[Option[A]]
52.  def minOption(implicit ord: ScalarOrd[A]): Ex[Option[A]]
53.  def mkString(start: Ex[String], sep: Ex[String], end: Ex[String]): Ex[String]
54.  def mkString(sep: Ex[String]): Ex[String]
55.  def mkString: Ex[String]
56.  def nonEmpty: Ex[Boolean]
57.  def padTo[B >: A](len: Ex[Int], elem: Ex[B]): Ex[Seq[B]]
58.  def patch[B >: A](from: Ex[Int], other: Ex[Seq[B]], replaced: Ex[Int]): Ex[Seq[B]]
59.  def permutations: Ex[Seq[Seq[A]]]
60.  def prepended[B >: A](elem: Ex[B]): Ex[Seq[B]]
61.  def product(implicit num: Num[A]): Ex[A]
62.  def reverse: Ex[Seq[A]]
63.  def sameElements[B >: A](that: Ex[Seq[B]]): Ex[Boolean]
64.  def select[B](implicit bridge: Bridge[B], ev: =:=[Ex[Seq[A]], Ex[Seq[graph.Obj]]]): Ex[Seq[B]]
65.  def selectFirst[B](implicit bridge: Bridge[B], ev: =:=[Ex[Seq[A]], Ex[Seq[graph.Obj]]]): Ex[Option[B]]
66.  def size: Ex[Int]

    The number of elements in the sequence

67.  def slice(from: Ex[Int], until: Ex[Int]): Ex[Seq[A]]
68.  def sliding(size: Ex[Int], step: Ex[Int] = 1): Ex[Seq[Seq[A]]]

    Groups elements in fixed size blocks by passing a "sliding window" over them.

    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.

69.  def sorted(implicit ord: ScalarOrd[A]): Ex[Seq[A]]
70.  def splitAt(n: Ex[Int]): Ex[(Seq[A], Seq[A])]
71.  def startsWith(that: Ex[Seq[A]], offset: Ex[Int] = 0): Ex[Boolean]

    Tests whether this sequence starts with that sequence

72.  def sum(implicit num: Num[A]): Ex[A]
73.  def take(n: Ex[Int]): Ex[Seq[A]]
74.  def takeRight(n: Ex[Int]): Ex[Seq[A]]
75.  def takeWhile(p: (Ex[A]) => Ex[Boolean]): Ex[Seq[A]]
76.  def toString(): String

    Definition Classes

    Any

77.  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.

    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.

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