trait Builder[-Elem, +To] extends Growable[Elem]
The base trait of all builders.
A builder lets one construct a collection incrementally, by adding
elements to the builder with +=
and then converting to the required
collection type with result
.
One cannot assume that a single Builder
can build more than one
instance of the desired collection. Particular subclasses may allow
such behavior. Otherwise, result
should be treated as a terminal
operation: after it is called, no further methods should be called on
the builder. Extend the collection.mutable.ReusableBuilder trait
instead of Builder
for builders that may be reused to build multiple
instances.
- Elem
the type of elements that get added to the builder.
- To
the type of collection that it produced.
- Source
- Builder.scala
- Since
2.8
- Alphabetic
- By Inheritance
- Builder
- Growable
- Clearable
- AnyRef
- Any
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- All
Abstract Value Members
-
abstract
def
+=(elem: Elem): Builder.this.type
Adds a single element to the builder.
-
abstract
def
clear(): Unit
Clears the contents of this builder.
-
abstract
def
result(): To
Produces a collection from the added elements.
Produces a collection from the added elements. This is a terminal operation: the builder's contents are undefined after this operation, and no further methods should be called.
- returns
a collection containing the elements added to this builder.
Concrete Value Members
-
def
++=(xs: TraversableOnce[Elem]): Builder.this.type
adds all elements produced by a TraversableOnce to this growable collection.
adds all elements produced by a TraversableOnce to this growable collection.
- xs
the TraversableOnce producing the elements to add.
- returns
the growable collection itself.
- Definition Classes
- Growable
-
def
+=(elem1: Elem, elem2: Elem, elems: Elem*): Builder.this.type
adds two or more elements to this growable collection.
adds two or more elements to this growable collection.
- elem1
the first element to add.
- elem2
the second element to add.
- elems
the remaining elements to add.
- returns
the growable collection itself
- Definition Classes
- Growable
-
def
mapResult[NewTo](f: (To) ⇒ NewTo): Builder[Elem, NewTo]
Creates a new builder by applying a transformation function to the results of this builder.
Creates a new builder by applying a transformation function to the results of this builder.
- NewTo
the type of collection returned by
f
.- f
the transformation function.
- returns
a new builder which is the same as the current builder except that a transformation function is applied to this builder's result.
- Note
The original builder should no longer be used after
mapResult
is called.
-
def
sizeHint(coll: TraversableLike[_, _], delta: Int): Unit
Gives a hint that one expects the
result
of this builder to have the same size as the given collection, plus some delta.Gives a hint that one expects the
result
of this builder to have the same size as the given collection, plus some delta. This will provide a hint only if the collection is known to have a cheapsize
method. Currently this is assumed to be the case if and only if the collection is of typeIndexedSeqLike
. Some builder classes will optimize their representation based on the hint. However, builder implementations are still required to work correctly even if the hint is wrong, i.e. a different number of elements is added.- coll
the collection which serves as a hint for the result's size.
- delta
a correction to add to the
coll.size
to produce the size hint.
-
def
sizeHint(coll: TraversableLike[_, _]): Unit
Gives a hint that one expects the
result
of this builder to have the same size as the given collection, plus some delta.Gives a hint that one expects the
result
of this builder to have the same size as the given collection, plus some delta. This will provide a hint only if the collection is known to have a cheapsize
method, which is determined by callingsizeHint
.Some builder classes will optimize their representation based on the hint. However, builder implementations are still required to work correctly even if the hint is wrong, i.e. a different number of elements is added.
- coll
the collection which serves as a hint for the result's size.
-
def
sizeHint(size: Int): Unit
Gives a hint how many elements are expected to be added when the next
result
is called.Gives a hint how many elements are expected to be added when the next
result
is called. Some builder classes will optimize their representation based on the hint. However, builder implementations are still required to work correctly even if the hint is wrong, i.e. a different number of elements is added.- size
the hint how many elements will be added.
-
def
sizeHintBounded(size: Int, boundingColl: TraversableLike[_, _]): Unit
Gives a hint how many elements are expected to be added when the next
result
is called, together with an upper bound given by the size of some other collection.Gives a hint how many elements are expected to be added when the next
result
is called, together with an upper bound given by the size of some other collection. Some builder classes will optimize their representation based on the hint. However, builder implementations are still required to work correctly even if the hint is wrong, i.e. a different number of elements is added.- size
the hint how many elements will be added.
- boundingColl
the bounding collection. If it is an IndexedSeqLike, then sizes larger than collection's size are reduced.
This is the documentation for the Scala standard library.
Package structure
The scala package contains core types like
Int
,Float
,Array
orOption
which are accessible in all Scala compilation units without explicit qualification or imports.Notable packages include:
scala.collection
and its sub-packages contain Scala's collections frameworkscala.collection.immutable
- Immutable, sequential data-structures such asVector
,List
,Range
,HashMap
orHashSet
scala.collection.mutable
- Mutable, sequential data-structures such asArrayBuffer
,StringBuilder
,HashMap
orHashSet
scala.collection.concurrent
- Mutable, concurrent data-structures such asTrieMap
scala.collection.parallel.immutable
- Immutable, parallel data-structures such asParVector
,ParRange
,ParHashMap
orParHashSet
scala.collection.parallel.mutable
- Mutable, parallel data-structures such asParArray
,ParHashMap
,ParTrieMap
orParHashSet
scala.concurrent
- Primitives for concurrent programming such asFutures
andPromises
scala.io
- Input and output operationsscala.math
- Basic math functions and additional numeric types likeBigInt
andBigDecimal
scala.sys
- Interaction with other processes and the operating systemscala.util.matching
- Regular expressionsOther packages exist. See the complete list on the right.
Additional parts of the standard library are shipped as separate libraries. These include:
scala.reflect
- Scala's reflection API (scala-reflect.jar)scala.xml
- XML parsing, manipulation, and serialization (scala-xml.jar)scala.swing
- A convenient wrapper around Java's GUI framework called Swing (scala-swing.jar)scala.util.parsing
- Parser combinators, including an example implementation of a JSON parser (scala-parser-combinators.jar)Automatic imports
Identifiers in the scala package and the
scala.Predef
object are always in scope by default.Some of these identifiers are type aliases provided as shortcuts to commonly used classes. For example,
List
is an alias forscala.collection.immutable.List
.Other aliases refer to classes provided by the underlying platform. For example, on the JVM,
String
is an alias forjava.lang.String
.