PairOfCols

Instance Constructors

new PairOfCols(ls: Coll[L], rs: Coll[R])

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
def append(other: Coll[(L, R)]): Coll[(L, R)]

Puts the elements of other collection after the elements of this collection (concatenation of 2 collections)
Puts the elements of other collection after the elements of this collection (concatenation of 2 collections)

Definition Classes
PairOfCols → Coll
def apply(i: Int): (L, R)

The element at given index.
The element at given index. Indices start at 0; xs.apply(0) is the first element of collection xs. Note the indexing syntax xs(i) is a shorthand for xs.apply(i).
i
the index
returns
the element at the given index

Definition Classes
PairOfCols → Coll
Annotations
@inline()
Exceptions thrown
ArrayIndexOutOfBoundsException if i < 0 or length <= i
final def asInstanceOf[T0]: T0

Definition Classes
Any
def builder: CollBuilder

Definition Classes
PairOfCols → Coll
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def diff(that: Coll[(L, R)]): Coll[(L, R)]

Computes the multiset difference between this collection and another sequence.
Computes the multiset difference between this collection and another sequence.
that
the sequence of elements to remove
returns
a new collection which contains all elements of this collection except some of occurrences of elements that also appear in that. If an element value x appears n times in that, then the first n occurrences of x will not form part of the result, but any following occurrences will.

Definition Classes
Coll
Since
2.0
def distinct: Coll[(L, R)]

Builds a new collection from this collection without any duplicate elements.
Builds a new collection from this collection without any duplicate elements.
returns
A new collection which contains the first occurrence of every element of this collection.

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

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

Definition Classes
PairOfCols → AnyRef → Any
def exists(p: ((L, R)) ⇒ Boolean): Boolean

Tests whether a predicate holds for at least one element of this collection.
Tests whether a predicate holds for at least one element of this collection.
p
the predicate used to test elements.
returns
true if the given predicate p is satisfied by at least one element of this collection, otherwise false

Definition Classes
PairOfCols → Coll
def filter(p: ((L, R)) ⇒ Boolean): Coll[(L, R)]

Selects all elements of this collection which satisfy a predicate.
Selects all elements of this collection which satisfy a predicate.
p
the predicate used to test elements.
returns
a new collection consisting of all elements of this collection that satisfy the given predicate p. The order of the elements is preserved.

Definition Classes
PairOfCols → Coll
Since
2.0
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def find(p: ((L, R)) ⇒ Boolean): Option[(L, R)]

Finds the first element of the collection satisfying a predicate, if any.
Finds the first element of the collection satisfying a predicate, if any.
p
the predicate used to test elements.
returns
an option value containing the first element in the collection that satisfies p, or None if none exists.

Definition Classes
Coll
Since
2.0
def flatMap[B](f: ((L, R)) ⇒ Coll[B])(implicit arg0: RType[B]): Coll[B]

Builds a new collection by applying a function to all elements of this collection and using the elements of the resulting collections.
Builds a new collection by applying a function to all elements of this collection and using the elements of the resulting collections.
Function f is constrained to be of the form x => x.someProperty, otherwise it is illegal.
B
the element type of the returned collection.
f
the function to apply to each element.
returns
a new collection of type Coll[B] resulting from applying the given collection-valued function f to each element of this collection and concatenating the results.

Definition Classes
PairOfCols → Coll
Since
2.0
def foldLeft[B](zero: B, op: ((B, (L, R))) ⇒ B): B

Applies a binary operator to a start value and all elements of this collection, going left to right.
Applies a binary operator to a start value and all elements of this collection, going left to right.
B
the result type of the binary operator.
zero
the start value.
op
the binary operator.
returns
the result of inserting op between consecutive elements of this collection, going left to right with the start value z on the left:
```
op(...op(z, x_1), x_2, ..., x_n)
```
where x_1, ..., x_n are the elements of this collection. Returns z if this collection is empty.
Definition Classes
PairOfCols → Coll
def forall(p: ((L, R)) ⇒ Boolean): Boolean

Tests whether a predicate holds for all elements of this collection.
Tests whether a predicate holds for all elements of this collection.
p
the predicate used to test elements.
returns
true if this collection is empty or the given predicate p holds for all elements of this collection, otherwise false.

Definition Classes
PairOfCols → Coll
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getOrElse(i: Int, default: (L, R)): (L, R)

The element of the collection or default value.
The element of the collection or default value. If an index is out of bounds (i < 0 || i >= length) then default value is returned.
i
the index
returns
the element at the given index or default value if index is out or bounds

Definition Classes
PairOfCols → Coll
Since
2.0
def hashCode(): Int

Definition Classes
PairOfCols → AnyRef → Any
def indexOf(elem: (L, R), from: Int): Int

Finds index of first occurrence of some value in this collection after or at some start index.
Finds index of first occurrence of some value in this collection after or at some start index.
elem
the element value to search for.
from
the start index
returns
the index >= from of the first element of this collection that is equal (as determined by ==) to elem, or -1, if none exists.

Definition Classes
Coll
Since
2.0
def indexWhere(p: ((L, R)) ⇒ Boolean, from: Int): Int

Finds index of the first element satisfying some predicate after or at some start index.
Finds index of the first element satisfying some predicate after or at some start index.
p
the predicate used to test elements.
from
the start index
returns
the index >= from of the first element of this collection that satisfies the predicate p, or -1, if none exists.

Definition Classes
PairOfCols → Coll
Since
2.0
def indices: Coll[Int]

Produces the range of all indices of this collection as a new collection containing [0 ..
Produces the range of all indices of this collection as a new collection containing [0 .. length-1] values.

Definition Classes
PairOfCols → Coll
Since
2.0
def intersect(that: Coll[(L, R)]): Coll[(L, R)]

Computes the multiset intersection between this collection and another sequence.
Computes the multiset intersection between this collection and another sequence.
that
the sequence of elements to intersect with.
returns
a new collection which contains all elements of this collection which also appear in that. If an element value x appears n times in that, then the first n occurrences of x will be retained in the result, but any following occurrences will be omitted.

Definition Classes
Coll
Since
2.0
def isDefinedAt(idx: Int): Boolean

Tests whether this collection contains given index.
Tests whether this collection contains given index.
The implementations of methods apply and isDefinedAt turn a Coll[A] into a PartialFunction[Int, A].
idx
the index to test
returns
true if this collection contains an element at position idx, false otherwise.

Definition Classes
PairOfCols → Coll
def isEmpty: Boolean

Tests whether the collection is empty.
Tests whether the collection is empty.
returns
true if the collection contains no elements, false otherwise.

Definition Classes
PairOfCols → Coll
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def isValidIndex(i: Int): Boolean

Returns true if the index in the valid range.
Returns true if the index in the valid range.
i
index of an element of this collection

Definition Classes
Coll
def lastIndexWhere(p: ((L, R)) ⇒ Boolean, end: Int): Int

Finds index of last element satisfying some predicate before or at given end index.
Finds index of last element satisfying some predicate before or at given end index.
p
the predicate used to test elements.
returns
the index <= end of the last element of this collection that satisfies the predicate p, or -1, if none exists.

Definition Classes
PairOfCols → Coll
Since
2.0
def length: Int

The length of the collection.
The length of the collection.

Definition Classes
PairOfCols → Coll
Annotations
@inline()
val ls: Coll[L]

Definition Classes
PairOfCols → PairColl
def map[V](f: ((L, R)) ⇒ V)(implicit arg0: RType[V]): Coll[V]

Builds a new collection by applying a function to all elements of this collection.
Builds a new collection by applying a function to all elements of this collection.
f
the function to apply to each element.
returns
a new collection of type Coll[B] resulting from applying the given function f to each element of this collection and collecting the results.

Definition Classes
PairOfCols → Coll
def mapFirst[T1](f: (L) ⇒ T1)(implicit arg0: RType[T1]): Coll[(T1, R)]

Definition Classes
PairOfCols → PairColl
def mapSecond[T1](f: (R) ⇒ T1)(implicit arg0: RType[T1]): Coll[(L, T1)]

Definition Classes
PairOfCols → PairColl
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def nonEmpty: Boolean

Tests whether the collection is not empty.
Tests whether the collection is not empty.
returns
true if the collection contains at least one element, false otherwise.

Definition Classes
PairOfCols → Coll
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def patch(from: Int, patch: Coll[(L, R)], replaced: Int): Coll[(L, R)]

Produces a new collection where a slice of elements in this collection is replaced by another sequence.
Produces a new collection where a slice of elements in this collection is replaced by another sequence.
from
the index of the first replaced element
patch
the replacement sequence
replaced
the number of elements to drop in the original collection
returns
a new collection consisting of all elements of this collection except that replaced elements starting from from are replaced by patch.

Definition Classes
PairOfCols → Coll
Since
2.0
def reverse: Coll[(L, R)]

Returns new collection with elements in reversed order.
Returns new collection with elements in reversed order.
returns
A new collection with all elements of this collection in reversed order.

Definition Classes
PairOfCols → Coll
val rs: Coll[R]

Definition Classes
PairOfCols → PairColl
def segmentLength(p: ((L, R)) ⇒ Boolean, from: Int): Int

Computes length of longest segment whose elements all satisfy some predicate.
Computes length of longest segment whose elements all satisfy some predicate.
p
the predicate used to test elements.
from
the index where the search starts.
returns
the length of the longest segment of this collection starting from index from such that every element of the segment satisfies the predicate p.

Definition Classes
PairOfCols → Coll
Since
2.0
def size: Int

The size of the collection in elements.
The size of the collection in elements.

Definition Classes
Coll
def slice(from: Int, until: Int): PairColl[L, R]

Selects an interval of elements.
Selects an interval of elements. The returned collection is made up of all elements x which satisfy the invariant:
```
from <= indexOf(x) < until
```
from
the lowest index to include from this collection.
until
the lowest index to EXCLUDE from this collection.

Definition Classes
PairOfCols → Coll
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
lazy val tItem: RType[(L, R)]

Definition Classes
PairOfCols → Coll
implicit def tL: RType[L]

Annotations
@inline()
implicit def tR: RType[R]

Annotations
@inline()
def take(n: Int): Coll[(L, R)]

Selects first n elements.
Selects first n elements.
n
the number of elements to take from this collection.
returns
a collection consisting only of the first n elements of this collection, or else the whole collection, if it has less than n elements. If n is negative, returns an empty collection.

Definition Classes
PairOfCols → Coll
def toArray: Array[(L, R)]

Definition Classes
PairOfCols → Coll
def toString(): String

Definition Classes
Coll → AnyRef → Any
def unionSet(that: Coll[(L, R)]): Coll[(L, R)]

Produces a new collection which contains all distinct elements of this collection and also all elements of a given collection that are not in this collection.
Produces a new collection which contains all distinct elements of this collection and also all elements of a given collection that are not in this collection. This is order preserving operation considering only first occurrences of each distinct elements. Any collection xs can be transformed to a sequence with distinct elements by using xs.unionSet(Col()).
NOTE: Use append if you don't need set semantics.
that
the collection to add.

Definition Classes
PairOfCols → Coll
Since
2.0
def updateMany(indexes: Coll[Int], values: Coll[(L, R)]): Coll[(L, R)]

Returns a copy of this collection where elements at indexes are replaced with values.
Returns a copy of this collection where elements at indexes are replaced with values.

Definition Classes
PairOfCols → Coll
Since
2.0
def updated(index: Int, elem: (L, R)): Coll[(L, R)]

A copy of this collection with one single replaced element.
A copy of this collection with one single replaced element.
index
the position of the replacement
elem
the replacing element
returns
a new collection which is a copy of this collection with the element at position index replaced by elem.

Definition Classes
PairOfCols → Coll
Since
2.0
Exceptions thrown
IndexOutOfBoundsException if index does not satisfy 0 <= index < length.
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( ... )
def zip[B](ys: Coll[B]): PairColl[(L, R), B]

For this collection (x0, ..., xN) and other collection (y0, ..., yM) produces a collection ((x0, y0), ..., (xK, yK)) where K = min(N, M)
For this collection (x0, ..., xN) and other collection (y0, ..., yM) produces a collection ((x0, y0), ..., (xK, yK)) where K = min(N, M)

Definition Classes
PairOfCols → Coll

Related Doc: package collection

class PairOfCols[L, R] extends PairColl[L, R]

Instance Constructors

new PairOfCols(ls: Coll[L], rs: Coll[R])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def append(other: Coll[(L, R)]): Coll[(L, R)]

def apply(i: Int): (L, R)

final def asInstanceOf[T0]: T0

def builder: CollBuilder

def clone(): AnyRef

def diff(that: Coll[(L, R)]): Coll[(L, R)]

def distinct: Coll[(L, R)]

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

def exists(p: ((L, R)) ⇒ Boolean): Boolean

def filter(p: ((L, R)) ⇒ Boolean): Coll[(L, R)]

def finalize(): Unit

def find(p: ((L, R)) ⇒ Boolean): Option[(L, R)]

def flatMap[B](f: ((L, R)) ⇒ Coll[B])(implicit arg0: RType[B]): Coll[B]

def foldLeft[B](zero: B, op: ((B, (L, R))) ⇒ B): B

def forall(p: ((L, R)) ⇒ Boolean): Boolean

final def getClass(): Class[_]

def getOrElse(i: Int, default: (L, R)): (L, R)

def hashCode(): Int

def indexOf(elem: (L, R), from: Int): Int

def indexWhere(p: ((L, R)) ⇒ Boolean, from: Int): Int

def indices: Coll[Int]

def intersect(that: Coll[(L, R)]): Coll[(L, R)]

def isDefinedAt(idx: Int): Boolean

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

final def isValidIndex(i: Int): Boolean

def lastIndexWhere(p: ((L, R)) ⇒ Boolean, end: Int): Int

def length: Int

val ls: Coll[L]

def map[V](f: ((L, R)) ⇒ V)(implicit arg0: RType[V]): Coll[V]

def mapFirst[T1](f: (L) ⇒ T1)(implicit arg0: RType[T1]): Coll[(T1, R)]

def mapSecond[T1](f: (R) ⇒ T1)(implicit arg0: RType[T1]): Coll[(L, T1)]

final def ne(arg0: AnyRef): Boolean

def nonEmpty: Boolean

final def notify(): Unit

final def notifyAll(): Unit

def patch(from: Int, patch: Coll[(L, R)], replaced: Int): Coll[(L, R)]

def reverse: Coll[(L, R)]

val rs: Coll[R]

def segmentLength(p: ((L, R)) ⇒ Boolean, from: Int): Int

def size: Int

def slice(from: Int, until: Int): PairColl[L, R]

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

lazy val tItem: RType[(L, R)]

implicit def tL: RType[L]

implicit def tR: RType[R]

def take(n: Int): Coll[(L, R)]

def toArray: Array[(L, R)]

def toString(): String

def unionSet(that: Coll[(L, R)]): Coll[(L, R)]

def updateMany(indexes: Coll[Int], values: Coll[(L, R)]): Coll[(L, R)]

def updated(index: Int, elem: (L, R)): Coll[(L, R)]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def zip[B](ys: Coll[B]): PairColl[(L, R), B]

Inherited from PairColl[L, R]

Inherited from Coll[(L, R)]

Inherited from AnyRef

Inherited from Any

Ungrouped