Scala 3

Learn Install Playground Find A Library Community Blog

Docs API

Generated with

Scala 3/scala/scala.collection/IterableOnceOps

IterableOnceOps

scala.collection.IterableOnceOps

traitIterableOnceOps[+A,+CC[_],+C]

This implementation trait can be mixed into anIterableOnce to get the basic methods that are shared betweenIterator andIterable. TheIterableOnce must support multiple calls toiterator but may or may not return the sameIterator every time.

Attributes

Source: IterableOnce.scala
Graph
Supertypes: classAny
Known subtypes: traitIterableOps[A,CC,C]
traitIterable[A]
traitMap[K,V]
classAbstractMap[K,V]
classHashMap[K,V]
classIntMap[T]
classListMap[K,V]
classLongMap[T]
classMap1[K,V]
classMap2[K,V]
classMap3[K,V]
classMap4[K,V]
classWithDefault[K,V]
classWithDefault[K,V]
classTreeMap[K,V]
classTreeSeqMap[K,V]
classVectorMap[K,V]
traitSeqMap[K,V]
traitSortedMap[K,V]
traitSeq[A]
classAbstractSeq[A]
classArraySeq[A]
classofBoolean
classofByte
classofChar
classofDouble
classofFloat
classofInt
classofLong
classofRef[T]
classofShort
classofUnit
classLazyList[A]
classList[A]
class::[A]
objectNil
classNumericRange[T]
classExclusive[T]
classInclusive[T]
classQueue[A]
classRange
classExclusive
classInclusive
classStream[A]
classCons[A]
objectEmpty
classVector[A]
classWrappedString
traitIndexedSeq[A]
traitLinearSeq[A]
traitSet[A]
classAbstractSet[A]
classBitSet
classBitSet1
classBitSet2
classBitSetN
classHashSet[A]
classListSet[A]
classSet1[A]
classSet2[A]
classSet3[A]
classSet4[A]
classSortedMapOps.this.ImmutableKeySortedSet
classTreeSet[A]
classEnumeration.this.ValueSet
traitSortedSet[A]
traitMapOps[K,V,CC,C]
traitSortedMapOps[K,V,CC,C]
traitStrictOptimizedSortedMapOps[K,V,CC,C]
traitStrictOptimizedMapOps[K,V,CC,C]
traitIterable[A]
classAbstractIterable[A]
classPriorityQueue[A]
traitMap[K,V]
traitMap[K,V]
classTrieMap[K,V]
classAbstractMap[K,V]
classAnyRefMap[K,V]
classCollisionProofHashMap[K,V]
classHashMap[K,V]
classLinkedHashMap[K,V]
classListMap[K,V]
classLongMap[V]
classWithDefault[K,V]
classWithDefault[K,V]
classOpenHashMap[Key,Value]
classTreeMap[K,V]
classSystemProperties
traitMultiMap[K,V]
traitSeqMap[K,V]
traitSortedMap[K,V]
traitSeq[A]
classAbstractSeq[A]
classAbstractBuffer[A]
classArrayBuffer[A]
classArrayDeque[A]
classQueue[A]
classStack[A]
classListBuffer[A]
classUnrolledBuffer[T]
classArraySeq[T]
classofBoolean
classofByte
classofChar
classofDouble
classofFloat
classofInt
classofLong
classofRef[T]
classofShort
classofUnit
classStringBuilder
traitBuffer[A]
traitIndexedBuffer[A]
traitIndexedSeq[T]
classAccumulator[A,CC,C]
classAnyAccumulator[A]
classDoubleAccumulator
classIntAccumulator
classLongAccumulator
traitSet[A]
classAbstractSet[A]
classBitSet
classHashSet[A]
classLinkedHashSet[A]
classTreeSet[A]
traitSortedSet[A]
traitMapOps[K,V,CC,C]
traitSortedMapOps[K,V,CC,C]
traitSetOps[A,CC,C]
traitSortedSetOps[A,CC,C]
traitEvidenceIterableFactoryDefaults[A,CC,Ev]
traitIterable[A]
classAbstractIterable[A]
classAbstractMap[K,V]
classAbstractSeq[A]
classAbstractSet[A]
classAbstractView[A]
classAbstractMapView[K,V]
classFilter[K,V]
classFilterKeys[K,V]
classId[K,V]
classMapValues[K,V,W]
classTapEach[K,V,U]
classAbstractSeqView[A]
classAbstractIndexedSeqView[A]
classArrayBufferView[A]
classSlice[A]
classStringView
classId[A]
classId[A]
classReverse[A]
classReverse[A]
classAppended[A]
classAppended[A]
classAppended[A]
classCollect[A,B]
classConcat[A]
classConcat[A]
classConcat[A]
classDistinctBy[A,B]
classDrop[A]
classDrop[A]
classDrop[A]
classDropRight[A]
classDropRight[A]
classDropRight[A]
classDropWhile[A]
classElems[A]
objectEmpty
classFill[A]
classFilter[A]
classFlatMap[A,B]
classIterate[A]
classLeftPartitionMapped[A,A1,A2]
classMap[A,B]
classMap[A,B]
classMap[A,B]
classPadTo[A]
classPrepended[A]
classPrepended[A]
classPrepended[A]
classRightPartitionMapped[A,A1,A2]
classScanLeft[A,B]
classSingle[A]
classTabulate[A]
classTake[A]
classTake[A]
classTake[A]
classTakeRight[A]
classTakeRight[A]
classTakeRight[A]
classTakeWhile[A]
classUnfold[A,S]
classUpdated[A]
classZip[A,B]
classZipAll[A,B]
classZipWithIndex[A]
traitMap[K,V]
traitDefaultMap[K,V]
traitSeqMap[K,V]
traitSortedMap[K,V]
traitSeq[A]
traitIndexedSeq[A]
traitLinearSeq[A]
traitSet[A]
traitSortedSet[A]
traitBitSet
traitView[A]
traitMapView[K,V]
traitSeqView[A]
traitIndexedSeqView[A]
classSorted[A,B]
traitIterableFactoryDefaults[A,CC]
traitMapFactoryDefaults[K,V,CC,WithFilterCC]
classWeakHashMap[K,V]
traitMapOps[K,V,CC,C]
traitSortedMapFactoryDefaults[K,V,CC,WithFilterCC,UnsortedCC]
traitSortedMapOps[K,V,CC,C]
traitStrictOptimizedSortedMapOps[K,V,CC,C]
traitStrictOptimizedMapOps[K,V,CC,C]
traitSeqOps[A,CC,C]
traitSeqOps[A,CC,C]
traitIndexedSeqOps[A,CC,C]
traitLinearSeqOps[A,CC,C]
traitStrictOptimizedSeqOps[A,CC,C]
traitSeqOps[A,CC,C]
traitIndexedSeqOps[A,CC,C]
traitIndexedSeqOps[A,CC,C]
traitLinearSeqOps[A,CC,C]
traitStrictOptimizedLinearSeqOps[A,CC,C]
traitStrictOptimizedSeqOps[A,CC,C]
traitArrayDequeOps[A,CC,C]
traitSetOps[A,CC,C]
traitSetOps[A,CC,C]
traitSortedSetOps[A,CC,C]
traitStrictOptimizedSortedSetOps[A,CC,C]
traitStrictOptimizedSetOps[A,CC,C]
traitSortedSetOps[A,CC,C]
traitBitSetOps[C]
traitSortedSetFactoryDefaults[A,CC,WithFilterCC]
traitStrictOptimizedSortedSetOps[A,CC,C]
traitStrictOptimizedSetOps[A,CC,C]
traitStrictOptimizedIterableOps[A,CC,C]
traitIterator[A]
classAbstractIterator[A]
classIterator.this.GroupedIterator[B]
classBufferedSource.this.BufferedLineIterator
classSource.this.LineIterator
classMatchIterator
traitBufferedIterator[A]
classSource
classBufferedSource
Show all
Self type: IterableOnce[A]

Members list

Value members

Abstract methods

defcollect[B](pf:PartialFunction[A,B]):CC[B]

Builds a new collection by applying a partial function to all elements of this collection on which the function is defined.

Type parameters

B: the element type of the returned collection.

Value parameters

pf: the partial function which filters and maps the collection.

Attributes

Returns: a new collection resulting from applying the given partial functionpf to each element on which it is defined and collecting the results. The order of the elements is preserved.
Source: IterableOnce.scala

defdrop(n:Int):C

Selects all elements except the firstn ones.

Note: might return different results for different runs, unless the underlying collection type is ordered.

Value parameters

n: the number of elements to drop from this collection.

Attributes

Returns: a collection consisting of all elements of this collection except the firstn ones, or else the empty collection, if this collection has less thann elements. Ifn is negative, don't drop any elements.
Source: IterableOnce.scala

defdropWhile(p:A=>Boolean):C

Selects all elements except the longest prefix that satisfies a predicate.

The matching prefix starts with the first element of this collection, and the element following the prefix is the first element that does not satisfy the predicate. The matching prefix may be empty, so that this method returns the entire collection.

Example:

scala> List(1, 2, 3, 100, 4).dropWhile(n => n < 10)val res0: List[Int] = List(100, 4)scala> List(1, 2, 3, 100, 4).dropWhile(n => n == 0)val res1: List[Int] = List(1, 2, 3, 100, 4)

Usespan to obtain both the prefix and suffix. UsefilterNot to drop all elements that satisfy the predicate.

Note: might return different results for different runs, unless the underlying collection type is ordered.

Value parameters

p: The predicate used to test elements.

Attributes

Returns: the longest suffix of this collection whose first element does not satisfy the predicatep.
Source: IterableOnce.scala

deffilter(p:A=>Boolean):C

Selects all elements of this collection which satisfy a predicate.

Value parameters

p: the predicate used to test elements.

Attributes

Returns: a new collection consisting of all elements of this collection that satisfy the given predicatep. The order of the elements is preserved.
Source: IterableOnce.scala

deffilterNot(pred:A=>Boolean):C

Selects all elements of this collection which do not satisfy a predicate.

Value parameters

pred: the predicate used to test elements.

Attributes

Returns: a new collection consisting of all elements of this collection that do not satisfy the given predicatepred. Their order may not be preserved.
Source: IterableOnce.scala

defflatMap[B](f:A=>IterableOnce[B]):CC[B]

Builds a new collection by applying a function to all elements of this collection and using the elements of the resulting collections.

For example:

def getWords(lines: Seq[String]): Seq[String] = lines flatMap (line => line split "\\W+")

The type of the resulting collection is guided by the static type of collection. This might cause unexpected results sometimes. For example:

// lettersOf will return a Seq[Char] of likely repeated letters, instead of a Setdef lettersOf(words: Seq[String]) = words flatMap (word => word.toSet)// lettersOf will return a Set[Char], not a Seqdef lettersOf(words: Seq[String]) = words.toSet flatMap ((word: String) => word.toSeq)// xs will be an Iterable[Int]val xs = Map("a" -> List(11,111), "b" -> List(22,222)).flatMap(_._2)// ys will be a Map[Int, Int]val ys = Map("a" -> List(1 -> 11,1 -> 111), "b" -> List(2 -> 22,2 -> 222)).flatMap(_._2)

Type parameters

B: the element type of the returned collection.

Value parameters

f: the function to apply to each element.

Attributes

Returns: a new collection resulting from applying the given collection-valued functionf to each element of this collection and concatenating the results.
Source: IterableOnce.scala

defflatten[B](implicitasIterable:A=>IterableOnce[B]):CC[B]

Converts this collection of iterable collections into a collection formed by the elements of these iterable collections.

The resulting collection's type will be guided by the type of collection. For example:

val xs = List(           Set(1, 2, 3),           Set(1, 2, 3)         ).flatten// xs == List(1, 2, 3, 1, 2, 3)val ys = Set(           List(1, 2, 3),           List(3, 2, 1)         ).flatten// ys == Set(1, 2, 3)

Type parameters

B: the type of the elements of each iterable collection.

Value parameters

asIterable: an implicit conversion which asserts that the element type of this collection is anIterable.

Attributes

Returns: a new collection resulting from concatenating all element collections.
Source: IterableOnce.scala

defmap[B](f:A=>B):CC[B]

Builds a new collection by applying a function to all elements of this collection.

Type parameters

B: the element type of the returned collection.

Value parameters

f: the function to apply to each element.

Attributes

Returns: a new collection resulting from applying the given functionf to each element of this collection and collecting the results.
Source: IterableOnce.scala

defscanLeft[B](z:B)(op: (B,A)=>B):CC[B]

Produces a collection containing cumulative results of applying the operator going left to right, including the initial value.

Note: will not terminate for infinite-sized collections.

Note: might return different results for different runs, unless the underlying collection type is ordered.

Type parameters

B: the type of the elements in the resulting collection

Value parameters

op: the binary operator applied to the intermediate result and the element
z: the initial value

Attributes

Returns: collection with intermediate results
Source: IterableOnce.scala

defslice(from:Int,until:Int):C

Selects an interval of elements.

Selects an interval of elements. The returned collection is made up of all elementsx which satisfy the invariant:

from <= indexOf(x) < until

Note: might return different results for different runs, unless the underlying collection type is ordered.

Value parameters

from: the lowest index to include from this collection.
until: the lowest index to EXCLUDE from this collection.

Attributes

Returns: a collection containing the elements greater than or equal to indexfrom extending up to (but not including) indexuntil of this collection.
Source: IterableOnce.scala

defspan(p:A=>Boolean): (C,C)

Splits this collection into a prefix/suffix pair according to a predicate.

Note:c span p is equivalent to (but possibly more efficient than)(c takeWhile p, c dropWhile p), provided the evaluation of the predicatep does not cause any side-effects.

Note: might return different results for different runs, unless the underlying collection type is ordered.

Value parameters

p: the test predicate

Attributes

Returns: a pair consisting of the longest prefix of this collection whose elements all satisfyp, and the rest of this collection.
Source: IterableOnce.scala

deftake(n:Int):C

Selects the firstn elements.

Note: might return different results for different runs, unless the underlying collection type is ordered.

Value parameters

n: the number of elements to take from this collection.

Attributes

Returns: a collection consisting only of the firstn elements of this collection, or else the whole collection, if it has less thann elements. Ifn is negative, returns an empty collection.
Source: IterableOnce.scala

deftakeWhile(p:A=>Boolean):C

Selects the longest prefix of elements that satisfy a predicate.

The matching prefix starts with the first element of this collection, and the element following the prefix is the first element that does not satisfy the predicate. The matching prefix may empty, so that this method returns an empty collection.

Example:

scala> List(1, 2, 3, 100, 4).takeWhile(n => n < 10)val res0: List[Int] = List(1, 2, 3)scala> List(1, 2, 3, 100, 4).takeWhile(n => n == 0)val res1: List[Int] = List()

Usespan to obtain both the prefix and suffix. Usefilter to retain only those elements from the entire collection that satisfy the predicate.

Note: might return different results for different runs, unless the underlying collection type is ordered.

Value parameters

p: The predicate used to test elements.

Attributes

Returns: the longest prefix of this collection whose elements all satisfy the predicatep.
Source: IterableOnce.scala

deftapEach[U](f:A=>U):C

Applies a side-effecting function to each element in this collection.

Applies a side-effecting function to each element in this collection. Strict collections will applyf to their elements immediately, while lazy collections like Views and LazyLists will only applyf on each element if and when that element is evaluated, and each time that element is evaluated.

Type parameters

U: the return type of f

Value parameters

f: a function to apply to each element in this collection

Attributes

Returns: The same logical collection as this
Source: IterableOnce.scala

defzipWithIndex:CC[(A,Int)]

Zips this collection with its indices.

Attributes

Returns: A new collection containing pairs consisting of all elements of this collection paired with their index. Indices start at0.
Example: List("a", "b", "c").zipWithIndex == List(("a", 0), ("b", 1), ("c", 2))
Source: IterableOnce.scala

Concrete methods

defaddString(b:StringBuilder,start:String,sep:String,end:String): b.type

Appends all elements of this collection to a string builder using start, end, and separator strings.

Appends all elements of this collection to a string builder using start, end, and separator strings. The written text begins with the stringstart and ends with the stringend. Inside, the string representations (w.r.t. the methodtoString) of all elements of this collection are separated by the stringsep.

Example:

scala> val a = List(1,2,3,4)a: List[Int] = List(1, 2, 3, 4)scala> val b = new StringBuilder()b: StringBuilder =scala> a.addString(b , "List(" , ", " , ")")res5: StringBuilder = List(1, 2, 3, 4)

Value parameters

b: the string builder to which elements are appended.
end: the ending string.
sep: the separator string.
start: the starting string.

Attributes

Returns: the string builderb to which elements were appended.
Source: IterableOnce.scala

finaldefaddString(b:StringBuilder,sep:String): b.type

Appends all elements of this collection to a string builder using a separator string.

Appends all elements of this collection to a string builder using a separator string. The written text consists of the string representations (w.r.t. the methodtoString) of all elements of this collection, separated by the stringsep.

Example:

scala> val a = List(1,2,3,4)a: List[Int] = List(1, 2, 3, 4)scala> val b = new StringBuilder()b: StringBuilder =scala> a.addString(b, ", ")res0: StringBuilder = 1, 2, 3, 4

Value parameters

b: the string builder to which elements are appended.
sep: the separator string.

Attributes

Returns: the string builderb to which elements were appended.
Source: IterableOnce.scala

finaldefaddString(b:StringBuilder): b.type

Appends all elements of this collection to a string builder.

Appends all elements of this collection to a string builder. The written text consists of the string representations (w.r.t. the methodtoString) of all elements of this collection without any separator string.

Example:

scala> val a = List(1,2,3,4)a: List[Int] = List(1, 2, 3, 4)scala> val b = new StringBuilder()b: StringBuilder =scala> val h = a.addString(b)h: StringBuilder = 1234

Value parameters

b: the string builder to which elements are appended.

Attributes

Returns: the string builderb to which elements were appended.
Source: IterableOnce.scala

defcollectFirst[B](pf:PartialFunction[A,B]):Option[B]

Finds the first element of the collection for which the given partial function is defined, and applies the partial function to it.

Note: may not terminate for infinite-sized collections.

Note: might return different results for different runs, unless the underlying collection type is ordered.

Value parameters

pf: the partial function

Attributes

Returns: an option value containing pf applied to the first value for which it is defined, orNone if none exists.
Example: Seq("a", 1, 5L).collectFirst({ case x: Int => x*10 }) = Some(10)
Source: IterableOnce.scala

defcopyToArray[B >:A](xs:Array[B]):Int

Copies elements to an array, returning the number of elements written.

Fills the given arrayxs starting at indexstart with values of this collection.

Copying will stop once either all the elements of this collection have been copied, or the end of the array is reached.

Type parameters

B: the type of the elements of the array.

Value parameters

xs: the array to fill.

Attributes

Returns: the number of elements written to the array
Note: Reuse: After calling this method, one should discard the iterator it was called on. Using it is undefined and subject to change.
Source: IterableOnce.scala

defcopyToArray[B >:A](xs:Array[B],start:Int):Int

Copies elements to an array, returning the number of elements written.

Fills the given arrayxs starting at indexstart with values of this collection.

Copying will stop once either all the elements of this collection have been copied, or the end of the array is reached.

Type parameters

B: the type of the elements of the array.

Value parameters

start: the starting index of xs.
xs: the array to fill.

Attributes

Returns: the number of elements written to the array
Note: Reuse: After calling this method, one should discard the iterator it was called on. Using it is undefined and subject to change.
Source: IterableOnce.scala

defcopyToArray[B >:A](xs:Array[B],start:Int,len:Int):Int

Copy elements to an array, returning the number of elements written.

Fills the given arrayxs starting at indexstart with at mostlen elements of this collection.

Copying will stop once either all the elements of this collection have been copied, or the end of the array is reached, orlen elements have been copied.

Type parameters

B: the type of the elements of the array.

Value parameters

len: the maximal number of elements to copy.
start: the starting index of xs.
xs: the array to fill.

Attributes

Returns: the number of elements written to the array
Note: Reuse: After calling this method, one should discard the iterator it was called on. Using it is undefined and subject to change.
Source: IterableOnce.scala

defcorresponds[B](that:IterableOnce[B])(p: (A,B)=>Boolean):Boolean

Tests whether every element of this collection's iterator relates to the corresponding element of another collection by satisfying a test predicate.

Note: will not terminate for infinite-sized collections.

Type parameters

B: the type of the elements ofthat

Value parameters

p: the test predicate, which relates elements from both collections
that: the other collection

Attributes

Returns: true if both collections have the same length andp(x, y) istrue for all corresponding elementsx of this iterator andy ofthat, otherwisefalse
Source: IterableOnce.scala

defcount(p:A=>Boolean):Int

Counts the number of elements in the collection which satisfy a predicate.

Note: will not terminate for infinite-sized collections.

Value parameters

p: the predicate used to test elements.

Attributes

Returns: the number of elements satisfying the predicatep.
Source: IterableOnce.scala

defexists(p:A=>Boolean):Boolean

Tests whether a predicate holds for at least one element of this collection.

Note: may not terminate for infinite-sized collections.

Value parameters

p: the predicate used to test elements.

Attributes

Returns: true if the given predicatep is satisfied by at least one element of this collection, otherwisefalse
Source: IterableOnce.scala

deffind(p:A=>Boolean):Option[A]

Finds the first element of the collection satisfying a predicate, if any.

Note: may not terminate for infinite-sized collections.

Note: might return different results for different runs, unless the underlying collection type is ordered.

Value parameters

p: the predicate used to test elements.

Attributes

Returns: an option value containing the first element in the collection that satisfiesp, orNone if none exists.
Source: IterableOnce.scala

deffold[A1 >:A](z:A1)(op: (A1,A1)=>A1):A1

Applies the given binary operatorop to the given initial valuez and all elements of this collection.

For each application of the operator, each operand is either an element of this collection, the initial value, or another such application of the operator.

The order of applications of the operator is unspecified and may be nondeterministic. Each element appears exactly once in the computation. The initial value may be used an arbitrary number of times, but at least once.

If this collection is ordered, then for any application of the operator, the element(s) appearing in the left operand will precede those in the right.

Note: might return different results for different runs, unless either of the following conditions is met: (1) the operator is associative, and the underlying collection type is ordered; or (2) the operator is associative and commutative. In either case, it is also necessary that the initial value be a neutral value for the operator, e.g.Nil forList concatenation or1 for multiplication.

The default implementation inIterableOnce is equivalent tofoldLeft but may be overridden for more efficient traversal orders.

Note: will not terminate for infinite-sized collections.

Type parameters

A1: The type parameter for the binary operator, a supertype ofA.

Value parameters

op: A binary operator; must be associative for the result to always be the same across runs.
z: An initial value; may be used an arbitrary number of times in the computation of the result; must be a neutral value forop for the result to always be the same across runs.

Attributes

Returns: The result of applyingop between all the elements andz, orz if this collection is empty.
Source: IterableOnce.scala

deffoldLeft[B](z:B)(op: (B,A)=>B):B

Applies the given binary operatorop to the given initial valuez and all elements of this collection, going left to right.

Applies the given binary operatorop to the given initial valuez and all elements of this collection, going left to right. Returns the initial value if this collection is empty.

"Going left to right" only makes sense if this collection is ordered: then ifx1,x2, ...,xn are the elements of this collection, the result isop( op( ... op( op(z, x1), x2) ... ), xn).

If this collection is not ordered, then for each application of the operator, each right operand is an element. In addition, the leftmost operand is the initial value, and each other left operand is itself an application of the operator. The elements of this collection and the initial value all appear exactly once in the computation.

Note: might return different results for different runs, unless the underlying collection type is ordered.

Note: will not terminate for infinite-sized collections.

Type parameters

B: The result type of the binary operator.

Value parameters

op: A binary operator.
z: An initial value.

Attributes

Returns: The result of applyingop toz and all elements of this collection, going left to right. Returnsz if this collection is empty.
Source: IterableOnce.scala

deffoldRight[B](z:B)(op: (A,B)=>B):B

Applies the given binary operatorop to all elements of this collection and the given initial valuez, going right to left.

Applies the given binary operatorop to all elements of this collection and the given initial valuez, going right to left. Returns the initial value if this collection is empty.

"Going right to left" only makes sense if this collection is ordered: then ifx1,x2, ...,xn are the elements of this collection, the result isop(x1, op(x2, op( ... op(xn, z) ... ))).

If this collection is not ordered, then for each application of the operator, each left operand is an element. In addition, the rightmost operand is the initial value, and each other right operand is itself an application of the operator. The elements of this collection and the initial value all appear exactly once in the computation.

Note: might return different results for different runs, unless the underlying collection type is ordered.

Note: will not terminate for infinite-sized collections.

Type parameters

B: The result type of the binary operator.

Value parameters

op: A binary operator.
z: An initial value.

Attributes

Returns: The result of applyingop to all elements of this collection andz, going right to left. Returnsz if this collection is empty.
Source: IterableOnce.scala

defforall(p:A=>Boolean):Boolean

Tests whether a predicate holds for all elements of this collection.

Note: may not terminate for infinite-sized collections.

Value parameters

p: the predicate used to test elements.

Attributes

Returns: true if this collection is empty or the given predicatep holds for all elements of this collection, otherwisefalse.
Source: IterableOnce.scala

defforeach[U](f:A=>U):Unit

Appliesf to each element for its side effects.

Appliesf to each element for its side effects. Note:U parameter needed to help scalac's type inference.

Attributes

Source: IterableOnce.scala

defisEmpty:Boolean

Tests whether the collection is empty.

Note: The default implementation creates and discards an iterator.

Note: Implementations in subclasses that are not repeatedly iterable must take care not to consume any elements whenisEmpty is called.

Attributes

Returns: true if the collection contains no elements,false otherwise.
Source: IterableOnce.scala

defisTraversableAgain:Boolean

Tests whether this collection can be repeatedly traversed.

Tests whether this collection can be repeatedly traversed. Always true for Iterables and false for Iterators unless overridden.

Attributes

Returns: true if it is repeatedly traversable,false otherwise.
Source: IterableOnce.scala

defmax[B >:A](implicitord:Ordering[B]):A

Finds the largest element.

Note: will not terminate for infinite-sized collections.

Type parameters

B: The type over which the ordering is defined.

Value parameters

ord: An ordering to be used for comparing elements.

Attributes

Returns: the largest element of this collection with respect to the orderingord.
Throws: UnsupportedOperationExceptionif this collection is empty.
Source: IterableOnce.scala

defmaxBy[B](f:A=>B)(implicitord:Ordering[B]):A

Finds the first element which yields the largest value measured by functionf.

Note: will not terminate for infinite-sized collections.

Type parameters

B: The result type of the functionf.

Value parameters

cmp: An ordering to be used for comparing elements.
f: The measuring function.

Attributes

Returns: the first element of this collection with the largest value measured by functionf with respect to the orderingcmp.
Throws: UnsupportedOperationExceptionif this collection is empty.
Source: IterableOnce.scala

defmaxByOption[B](f:A=>B)(implicitord:Ordering[B]):Option[A]

Finds the first element which yields the largest value measured by functionf.

Note: will not terminate for infinite-sized collections.

Type parameters

B: The result type of the functionf.

Value parameters

cmp: An ordering to be used for comparing elements.
f: The measuring function.

Attributes

Returns: an option value containing the first element of this collection with the largest value measured by functionf with respect to the orderingcmp.
Source: IterableOnce.scala

defmaxOption[B >:A](implicitord:Ordering[B]):Option[A]

Finds the largest element.

Note: will not terminate for infinite-sized collections.

Type parameters

B: The type over which the ordering is defined.

Value parameters

ord: An ordering to be used for comparing elements.

Attributes

Returns: an option value containing the largest element of this collection with respect to the orderingord.
Source: IterableOnce.scala

defmin[B >:A](implicitord:Ordering[B]):A

Finds the smallest element.

Note: will not terminate for infinite-sized collections.

Type parameters

B: The type over which the ordering is defined.

Value parameters

ord: An ordering to be used for comparing elements.

Attributes

Returns: the smallest element of this collection with respect to the orderingord.
Throws: UnsupportedOperationExceptionif this collection is empty.
Source: IterableOnce.scala

defminBy[B](f:A=>B)(implicitord:Ordering[B]):A

Finds the first element which yields the smallest value measured by functionf.

Note: will not terminate for infinite-sized collections.

Type parameters

B: The result type of the functionf.

Value parameters

cmp: An ordering to be used for comparing elements.
f: The measuring function.

Attributes

Returns: the first element of this collection with the smallest value measured by functionf with respect to the orderingcmp.
Throws: UnsupportedOperationExceptionif this collection is empty.
Source: IterableOnce.scala

defminByOption[B](f:A=>B)(implicitord:Ordering[B]):Option[A]

Finds the first element which yields the smallest value measured by functionf.

Note: will not terminate for infinite-sized collections.

Type parameters

B: The result type of the functionf.

Value parameters

cmp: An ordering to be used for comparing elements.
f: The measuring function.

Attributes

Returns: an option value containing the first element of this collection with the smallest value measured by functionf with respect to the orderingcmp.
Source: IterableOnce.scala

defminOption[B >:A](implicitord:Ordering[B]):Option[A]

Finds the smallest element.

Note: will not terminate for infinite-sized collections.

Type parameters

B: The type over which the ordering is defined.

Value parameters

ord: An ordering to be used for comparing elements.

Attributes

Returns: an option value containing the smallest element of this collection with respect to the orderingord.
Source: IterableOnce.scala

finaldefmkString(start:String,sep:String,end:String):String

Displays all elements of this collection in a string using start, end, and separator strings.

Delegates to addString, which can be overridden.

Value parameters

end: the ending string.
sep: the separator string.
start: the starting string.

Attributes

Returns: a string representation of this collection. The resulting string begins with the stringstart and ends with the stringend. Inside, the string representations (w.r.t. the methodtoString) of all elements of this collection are separated by the stringsep.
Example: List(1, 2, 3).mkString("(", "; ", ")") = "(1; 2; 3)"
Source: IterableOnce.scala

finaldefmkString(sep:String):String

Displays all elements of this collection in a string using a separator string.

Delegates to addString, which can be overridden.

Value parameters

sep: the separator string.

Attributes

Returns: a string representation of this collection. In the resulting string the string representations (w.r.t. the methodtoString) of all elements of this collection are separated by the stringsep.
Example: List(1, 2, 3).mkString("|") = "1|2|3"
Source: IterableOnce.scala

finaldefmkString:String

Displays all elements of this collection in a string.

Delegates to addString, which can be overridden.

Attributes

Returns: a string representation of this collection. In the resulting string the string representations (w.r.t. the methodtoString) of all elements of this collection follow each other without any separator string.
Source: IterableOnce.scala

defnonEmpty:Boolean

Tests whether the collection is not empty.

Attributes

Returns: true if the collection contains at least one element,false otherwise.
Source: IterableOnce.scala

defproduct[B >:A](implicitnum:Numeric[B]):B

Multiplies together the elements of this collection.

The default implementation usesreduce for a known non-empty collection,foldLeft otherwise.

Note: will not terminate for infinite-sized collections.

Type parameters

B: the result type of the* operator.

Value parameters

num: an implicit parameter defining a set of numeric operations which includes the* operator to be used in forming the product.

Attributes

Returns: the product of all elements of this collection with respect to the* operator innum.
Source: IterableOnce.scala

defreduce[B >:A](op: (B,B)=>B):B

Applies the given binary operatorop to all elements of this collection.

For each application of the operator, each operand is either an element of this collection or another such application of the operator. The order of applications of the operator is unspecified and may be nondeterministic. Each element appears exactly once in the computation.

If this collection is ordered, then for any application of the operator, the element(s) appearing in the left operand will precede those in the right.

Note: will not terminate for infinite-sized collections.

Type parameters

B: The type parameter for the binary operator, a supertype ofA.

Value parameters

op: A binary operator; must be associative for the result to always be the same across runs.

Attributes

Returns: The result of applyingop between all the elements if the collection is nonempty.
Throws: UnsupportedOperationExceptionif this collection is empty.
Source: IterableOnce.scala

defreduceLeft[B >:A](op: (B,A)=>B):B

Applies the given binary operatorop to all elements of this collection, going left to right.

"Going left to right" only makes sense if this collection is ordered: then ifx1,x2, ...,xn are the elements of this collection, the result isop( op( op( ... op(x1, x2) ... ), xn-1), xn).

If this collection is not ordered, then for each application of the operator, each right operand is an element. In addition, the leftmost operand is the first element of this collection and each other left operand is itself an application of the operator. Each element appears exactly once in the computation.

Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.

Note: will not terminate for infinite-sized collections.

Type parameters

B: The result type of the binary operator, a supertype ofA.

Value parameters

op: A binary operator.

Attributes

Returns: The result of applyingop to all elements of this collection, going left to right.
Throws: UnsupportedOperationExceptionif this collection is empty.
Source: IterableOnce.scala

defreduceLeftOption[B >:A](op: (B,A)=>B):Option[B]

If this collection is nonempty, reduces it with the given binary operatorop, going left to right.

The behavior is the same asreduceLeft except that the value isNone if the collection is empty. Each element appears exactly once in the computation.

Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.

Note: will not terminate for infinite-sized collections.

Type parameters

B: The result type of the binary operator, a supertype ofA.

Value parameters

op: A binary operator.

Attributes

Returns: The result of reducing this collection withop going left to right if the collection is nonempty, inside aSome, andNone otherwise.
Source: IterableOnce.scala

defreduceOption[B >:A](op: (B,B)=>B):Option[B]

If this collection is nonempty, reduces it with the given binary operatorop.

The behavior is the same asreduce except that the value isNone if the collection is empty. The order of applications of the operator is unspecified and may be nondeterministic. Each element appears exactly once in the computation.

Note: will not terminate for infinite-sized collections.

Type parameters

B: A type parameter for the binary operator, a supertype ofA.

Value parameters

op: A binary operator; must be associative for the result to always be the same across runs.

Attributes

Returns: The result of reducing this collection withop if the collection is nonempty, inside aSome, andNone otherwise.
Source: IterableOnce.scala

defreduceRight[B >:A](op: (A,B)=>B):B

Applies the given binary operatorop to all elements of this collection, going right to left.

"Going right to left" only makes sense if this collection is ordered: then ifx1,x2, ...,xn are the elements of this collection, the result isop(x1, op(x2, op( ... op(xn-1, xn) ... ))).

If this collection is not ordered, then for each application of the operator, each left operand is an element. In addition, the rightmost operand is the last element of this collection and each other right operand is itself an application of the operator. Each element appears exactly once in the computation.

Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.

Note: will not terminate for infinite-sized collections.

Type parameters

B: The result type of the binary operator, a supertype ofA.

Value parameters

op: A binary operator.

Attributes

Returns: The result of applyingop to all elements of this collection, going right to left.
Throws: UnsupportedOperationExceptionif this collection is empty.
Source: IterableOnce.scala

defreduceRightOption[B >:A](op: (A,B)=>B):Option[B]

If this collection is nonempty, reduces it with the given binary operatorop, going right to left.

The behavior is the same asreduceRight except that the value isNone if the collection is empty. Each element appears exactly once in the computation.

Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.

Note: will not terminate for infinite-sized collections.

Type parameters

B: The result type of the binary operator, a supertype ofA.

Value parameters

op: A binary operator.

Attributes

Returns: The result of reducing this collection withop going right to left if the collection is nonempty, inside aSome, andNone otherwise.
Source: IterableOnce.scala

protecteddefreversed:Iterable[A]

Attributes

Source: IterableOnce.scala

defsize:Int

The size of this collection.

Note: will not terminate for infinite-sized collections.

Attributes

Returns: the number of elements in this collection.
Source: IterableOnce.scala

defsplitAt(n:Int): (C,C)

Splits this collection into a prefix/suffix pair at a given position.

Note:c splitAt n is equivalent to (but possibly more efficient than)(c take n, c drop n).

Note: might return different results for different runs, unless the underlying collection type is ordered.

Value parameters

n: the position at which to split.

Attributes

Returns: a pair of collections consisting of the firstn elements of this collection, and the other elements.
Source: IterableOnce.scala

defsum[B >:A](implicitnum:Numeric[B]):B

Sums the elements of this collection.

The default implementation usesreduce for a known non-empty collection,foldLeft otherwise.

Note: will not terminate for infinite-sized collections.

Type parameters

B: the result type of the+ operator.

Value parameters

num: an implicit parameter defining a set of numeric operations which includes the+ operator to be used in forming the sum.

Attributes

Returns: the sum of all elements of this collection with respect to the+ operator innum.
Source: IterableOnce.scala

defto[C1](factory:Factory[A,C1]):C1

Given a collection factoryfactory, converts this collection to the appropriate representation for the current element typeA.

Given a collection factoryfactory, converts this collection to the appropriate representation for the current element typeA. Example uses:

xs.to(List)xs.to(ArrayBuffer)xs.to(BitSet) // for xs: Iterable[Int]

Attributes

Source: IterableOnce.scala

deftoArray[B >:A :ClassTag]:Array[B]

Converts this collection to anArray.

Implementation note: DO NOT callArray.from from this method.

Type parameters

B: The type of elements of the result, a supertype ofA.

Attributes

Returns: This collection as anArray[B].
Source: IterableOnce.scala

finaldeftoBuffer[B >:A]:Buffer[B]

Converts this collection to aBuffer.

Type parameters

B: The type of elements of the result, a supertype ofA.

Attributes

Returns: This collection as aBuffer[B].
Source: IterableOnce.scala

deftoIndexedSeq:IndexedSeq[A]

Converts this collection to anIndexedSeq.

Attributes

Returns: This collection as anIndexedSeq[A].
Source: IterableOnce.scala

deftoList:List[A]

Converts this collection to aList.

Attributes

Returns: This collection as aList[A].
Source: IterableOnce.scala

deftoMap[K,V](implicitev:A<:< (K,V)):Map[K,V]

Converts this collection to aMap, given an implicit coercion from the collection's type to a key-value tuple.

Type parameters

K: The key type for the resulting map.
V: The value type for the resulting map.

Value parameters

ev: An implicit coercion fromA to[K, V].

Attributes

Returns: This collection as aMap[K, V].
Source: IterableOnce.scala

deftoSeq:Seq[A]

Attributes

Returns: This collection as aSeq[A]. This is equivalent toto(Seq) but might be faster.
Source: IterableOnce.scala

deftoSet[B >:A]:Set[B]

Converts this collection to aSet.

Type parameters

B: The type of elements of the result, a supertype ofA.

Attributes

Returns: This collection as aSet[B].
Source: IterableOnce.scala

deftoVector:Vector[A]

Converts this collection to aVector.

Attributes

Returns: This collection as aVector[A].
Source: IterableOnce.scala

Deprecated methods

finaldef/:[B](z:B)(op: (B,A)=>B):B

Attributes

Deprecated: [Since version 2.13.0]Use foldLeft instead of /:
Source: IterableOnce.scala

finaldef:\[B](z:B)(op: (A,B)=>B):B

Attributes

Deprecated: [Since version 2.13.0]Use foldRight instead of :\\
Source: IterableOnce.scala

defaggregate[B](z:=>B)(seqop: (B,A)=>B,combop: (B,B)=>B):B

Aggregates the results of applying an operator to subsequent elements.

Since this method degenerates tofoldLeft for sequential (non-parallel) collections, where the combining operation is ignored, it is advisable to preferfoldLeft for that case.

Forparallel collections, use theaggregate method specified byscala.collection.parallel.ParIterableLike.

Type parameters

B: the result type, produced byseqop,combop, and by this function as a final result.

Value parameters

combop: an associative operator for combining sequential results, unused for sequential collections.
seqop: the binary operator used to accumulate the result.
z: the start value, a neutral element forseqop.

Attributes

Deprecated: [Since version 2.13.0]For sequential collections, prefer `foldLeft(z)(seqop)`. For parallel collections, use `ParIterableLike#aggregate`.
Source: IterableOnce.scala

finaldefcopyToBuffer[B >:A](dest:Buffer[B]):Unit

Attributes

Deprecated: [Since version 2.13.0]Use `dest ++= coll` instead
Source: IterableOnce.scala

defhasDefiniteSize:Boolean

Tests whether this collection is known to have a finite size.

Tests whether this collection is known to have a finite size. All strict collections are known to have finite size. For a non-strict collection such asStream, the predicate returnstrue if all elements have been computed. It returnsfalse if the stream is not yet evaluated to the end. Non-empty Iterators usually returnfalse even if they were created from a collection with a known finite size.

Note: many collection methods will not work on collections of infinite sizes. The typical failure mode is an infinite loop. These methods always attempt a traversal without checking first thathasDefiniteSize returnstrue. However, checkinghasDefiniteSize can provide an assurance that size is well-defined and non-termination is not a concern.

Attributes

Returns: true if this collection is known to have finite size,false otherwise.
See also: methodknownSize for a more useful alternative
Deprecated: [Since version 2.13.0]Check .knownSize instead of .hasDefiniteSize for more actionable information (see scaladoc for details)
This method is deprecated in 2.13 because it does not provide any actionable information. As noted above, even the collection library itself does not use it. When there is no guarantee that a collection is finite, it is generally best to attempt a computation anyway and document that it will not terminate for infinite collections rather than backing out because this would prevent performing the computation on collections that are in fact finite even thoughhasDefiniteSize returnsfalse.
Source: IterableOnce.scala

finaldeftoIterator:Iterator[A]

Attributes

Deprecated: [Since version 2.13.0]Use .iterator instead of .toIterator
Source: IterableOnce.scala

finaldeftoStream:Stream[A]

Attributes

Deprecated: [Since version 2.13.0]Use .to(LazyList) instead of .toStream
Source: IterableOnce.scala

In this article

Generated with

Movatterモバイル変換

IterableOnceOps

Attributes

Members list

Value members

Abstract methods

Type parameters

Value parameters

Attributes

Value parameters

Attributes

Value parameters

Attributes

Value parameters

Attributes

Value parameters

Attributes

Type parameters

Value parameters

Attributes

Type parameters

Value parameters

Attributes

Type parameters

Value parameters

Attributes

Type parameters

Value parameters

Attributes

Value parameters

Attributes

Value parameters

Attributes

Value parameters

Attributes

Value parameters

Attributes

Type parameters

Value parameters

Attributes

Attributes

Concrete methods

Value parameters

Attributes

Value parameters

Attributes

Value parameters

Attributes

Value parameters

Attributes

Type parameters

Value parameters

Attributes

Type parameters

Value parameters

Attributes

Type parameters

Value parameters

Attributes

Type parameters

Value parameters

Attributes

Value parameters

Attributes

Value parameters

Attributes

Value parameters

Attributes

Type parameters

Value parameters

Attributes

Type parameters

Value parameters

Attributes

Type parameters

Value parameters

Attributes

Value parameters

Attributes

Attributes