Scala Library
|
|
scala/collection/SeqProxyLike.scala
]
trait
SeqProxyLike[+A, +This <: SeqLike[A, This] with
Seq[A]]
extends
SeqLike[A, This] with
IterableProxyLike[A, This]Method Summary | |
override def
|
apply
(idx : Int) : A
Returns the elements at position `idx`
|
override def
|
contains
(elem : Any) : Boolean
Tests if the given value
elem is a member of this
sequence. |
override def
|
containsSlice
[B](that : Seq[B]) : Boolean
Is
that a slice in this? |
override def
|
diff [B >: A, That](that : Seq[B]) : This |
override def
|
endsWith [B](that : Seq[B]) : Boolean |
override def
|
equalsWith [B](that : Seq[B])(f : (A, B) => Boolean) : Boolean |
override def
|
findIndexOf
(p : (A) => Boolean) : Int
Returns index of the first element satisying a predicate, or -1.
|
override def
|
indexOf
[B >: A](elem : B, from : Int) : Int
Returns the index of the first occurence of the specified
object in this sequence, starting from a start index, or
-1, if none exists.
|
override def
|
indexOf
[B >: A](elem : B) : Int
Returns the index of the first occurence of the specified
object in this sequence.
|
override def
|
indexOfSeq [B >: A](that : Seq[B]) : Int |
override def
|
indexWhere
(p : (A) => Boolean, from : Int) : Int
Returns index of the first element starting from a start index
satisying a predicate, or -1, if none exists.
|
override def
|
indexWhere
(p : (A) => Boolean) : Int
Returns index of the first element satisfying a predicate, or -1, if none exists.
|
override def
|
indices
: Range
The range of all indices of this sequence.
|
override def
|
intersect [B >: A, That](that : Seq[B]) : This |
override def
|
isDefinedAt
(x : Int) : Boolean
Is this partial function defined for the index
x ? |
override def
|
lastIndexOf
[B >: A](elem : B) : Int
Returns the index of the last occurence of the specified element
in this sequence, or -1 if the sequence does not contain this element.
|
override def
|
lastIndexOf
[B >: A](elem : B, end : Int) : Int
Returns the index of the last
occurence of the specified element in this sequence
before or at a given end index,
or -1 if the sequence does not contain this element.
|
override def
|
lastIndexWhere
(p : (A) => Boolean, end : Int) : Int
Returns index of the last element not exceeding a given end index
and satisying a predicate, or -1 if none exists.
|
override def
|
lastIndexWhere
(p : (A) => Boolean) : Int
Returns index of the last element satisying a predicate, or -1, if none exists.
|
override def
|
length
: Int
Returns the length of the sequence.
|
override def
|
lengthCompare
(len : Int) : Int
Result of comparing
length with operand len .
returns x where
x < 0 iff this.length < len
x == 0 iff this.length == len
x > 0 iff this.length > len .
The method as implemented here does not call length directly; its running time
is O(length min len) instead of O(length). The method should be overwritten
if computing length is cheap. |
override def
|
padTo
[B >: A, That](len : Int, elem : B)(implicit bf : CanBuildFrom[This, B, That]) : That
Returns a new sequence of given length containing the elements of this sequence followed by zero
or more occurrences of given elements.
|
override def
|
patch
[B >: A, That](from : Int, patch : Seq[B], replaced : Int)(implicit bf : CanBuildFrom[This, B, That]) : That
A new sequence, consisting of all elements of current sequence
except that `replaced` elements starting from `from` are replaced
by `patch`.
|
override def
|
prefixLength
(p : (A) => Boolean) : Int
Returns length of longest prefix of this seqence
such that every element of the prefix satisfies predicate `p`.
|
override def
|
removeDuplicates
: This
Builds a new sequence from this sequence in which any duplicates (wrt to ==) removed.
Among duplicate elements, only the first one is retained in the result sequence
|
override def
|
reverse
: This
A sequence of type
C consisting of all elements of
this sequence in reverse order. |
override def
|
reverseIterator
: Iterator[A]
The elements of this sequence in reversed order
|
override def
|
segmentLength
(p : (A) => Boolean, from : Int) : Int
Returns length of longest segment starting from a start index `from`
such that every element of the segment satisfies predicate `p`.
|
override def
|
size
: Int
Should always be
length |
override def
|
startsWith
[B](that : Seq[B]) : Boolean
Check whether the receiver object starts with the argument sequence.
|
override def
|
startsWith
[B](that : Seq[B], offset : Int) : Boolean
Checks whether the argument sequence is contained at the
specified index within the receiver object.
If the both the receiver object,
this and
the argument, that are infinite sequences
this method may not terminate. |
override def
|
union
[B >: A, That](that : Seq[B])(implicit bf : CanBuildFrom[This, B, That]) : That
|
override def
|
view
(from : Int, until : Int) : SeqView[A, This]
A sub-iterable view starting at index `from`
and extending up to (but not including) index `until`.
|
override def
|
view
: SeqView[A, This]
Creates a view of this iterable @see IterableView
|
Methods inherited from IterableProxyLike | |
iterator, foreach, isEmpty, foldRight, reduceRight, toIterable, zip, zipAll, zipWithIndex, head, takeRight, dropRight, sameElements, toStream |
Methods inherited from TraversableProxyLike | |
self (abstract), nonEmpty, hasDefiniteSize, ++, ++, map, flatMap, filter, filterNot, remove, partition, groupBy, forall, exists, count, find, foldLeft, /:, :\, reduceLeft, reduceLeftOption, reduceRightOption, headOption, tail, last, lastOption, init, take, drop, slice, takeWhile, dropWhile, span, splitAt, copyToBuffer, copyToArray, copyToArray, toArray, toList, toSeq, toSet, mkString, mkString, mkString, addString, addString, addString, stringPrefix |
Methods inherited from Proxy | |
hashCode, equals, toString |
Methods inherited from SeqLike | |
thisCollection, toCollection, reverseMap, reversedElements, indexOfSeq, lastIndexOfSeq, lastIndexOfSeq, updated, +:, :+, sortWith, sortWith, sortBy, findLastIndexOf, projection |
Methods inherited from IterableLike | |
elements, canEqual, first, firstOption |
Methods inherited from TraversableLike | |
newBuilder (abstract), repr, partialMap, sum, product, min, max, toIndexedSeq, withFilter |
Methods inherited from AnyRef | |
getClass, clone, notify, notifyAll, wait, wait, wait, finalize, ==, !=, eq, ne, synchronized |
Methods inherited from Any | |
==, !=, isInstanceOf, asInstanceOf |
Method Details |
override
def
length : Int
length
with operand len
.
returns x
where
x < 0
iff this.length < len
x == 0
iff this.length == len
x > 0
iff this.length > len
.
The method as implemented here does not call length directly; its running time
is O(length min len) instead of O(length). The method should be overwritten
if computing length is cheap.override
def
size : Int
length
x
?p -
the predicatefrom -
the start indexp -
the predicatep -
the predicatep -
the predicatefrom -
the start indexelem -
element to search for.elem -
element to search for.elem -
element to search for.elem -
element to search for.end -
the end indexp -
the predicatep
, or -1 if such an element does not existend -
the end indexp -
the predicateoverride
def
reverse : This
C
consisting of all elements of
this sequence in reverse order.this
and
the argument, that
are infinite sequences
this method may not terminate.that
is contained in this
, at the specified index, otherwise falsethat
is a prefix of this
, otherwise falsethat
not contained in this, otherwise the first index where that
is contained.elem
is a member of this
sequence.elem -
element whose membership has to be tested.true
iff there is an element of this sequence which is equal (w.r.t. ==
) to elem
.
Computes the multiset union of this sequence and the given sequence
that
. For example:
val xs = List(1, 1, 2) val ys = List(1, 2, 2, 3) println(xs union ys) // prints "List(1, 1, 2, 1, 2, 2, 3)" println(ys union xs) // prints "List(1, 2, 2, 3, 1, 1, 2)"
that -
the sequence of elements to add to the sequence.that
.
Computes the multiset difference between this sequence and the
given sequence that
. If an element appears more
than once in both sequences, the difference contains m copies
of that element, where m is the difference between the
number of times the element appears in this sequence and the number
of times it appears in that
. For example:
val xs = List(1, 1, 2) val ys = List(1, 2, 2, 3) println(xs diff ys) // prints "List(1)" println(xs -- ys) // prints "List()"
that -
the sequence of elements to remove from this sequence.
Computes the multiset intersection between this sequence and the
given sequence that
; the intersection contains m
copies of an element contained in both sequences, where m is
the smaller of the number of times the element appears in this
sequence or in that
. For example:
val xs = List(1, 1, 2) val ys = List(3, 2, 2, 1) println(xs intersect ys) // prints "List(1, 2)" println(ys intersect xs) // prints "List(2, 1)"
that -
the sequence to intersect.that
.override
def
removeDuplicates : This
override
def
patch[B >: A, That](from : Int, patch : Seq[B], replaced : Int)(implicit
bf : CanBuildFrom[This, B, That]) : That
override
def
padTo[B >: A, That](len : Int, elem : B)(implicit
bf : CanBuildFrom[This, B, That]) : That
override
def
indices : Range
from -
The index of the first element of the sliceuntil -
The index of the element following the slicethat
a slice in this?
Scala Library
|
|