package generic
- Alphabetic
- By Inheritance
- generic
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- trait DefaultSerializable extends Serializable
Mix-in trait to enable DefaultSerializationProxy for the standard collection types.
Mix-in trait to enable DefaultSerializationProxy for the standard collection types. Depending on the type it is mixed into, it will dynamically choose
iterableFactory
,mapFactory
,sortedIterableFactory
orsortedMapFactory
for deserialization into the respectiveCC
type. OverridewriteReplace
or implement it directly without using this trait if you need a non-standard factory or if you want to use a different serialization scheme. - final class DefaultSerializationProxy[A] extends Serializable
The default serialization proxy for collection implementations.
The default serialization proxy for collection implementations.
This class is
final
and requires an extraFactory
object rather than leaving the details of creating aBuilder
to an abstract method that could be implemented by a subclass. This is necessary because the factory is needed for deserializing this class's private state, which happens before any subclass fields would be deserialized. Any additional state required to create the properBuilder
needs to be captured by thefactory
.- Annotations
- @SerialVersionUID()
- trait IsIterable[Repr] extends IsIterableOnce[Repr]
A trait which can be used to avoid code duplication when defining extension methods that should be applicable both to existing Scala collections (i.e., types extending
Iterable
) as well as other (potentially user-defined) types that could be converted to a Scala collection type.A trait which can be used to avoid code duplication when defining extension methods that should be applicable both to existing Scala collections (i.e., types extending
Iterable
) as well as other (potentially user-defined) types that could be converted to a Scala collection type. This trait makes it possible to treat Scala collections and types that can be implicitly converted to a collection type uniformly. For example, one can provide extension methods that work both on collection types and onString
s (String
s do not extendIterable
, but can be converted toIterable
)IsIterable
provides three members:- type member
A
, which represents the element type of the targetIterable[A]
- type member
C
, which represents the type returned by transformation operations that preserve the collection’s elements type - method
apply
, which provides a way to convert between the type we wish to add extension methods to,Repr
, andIterableOps[A, Iterable, C]
.
Usage
One must provide
IsIterable
as an implicit parameter type of an implicit conversion. Its usage is shown below. Our objective in the following example is to provide a generic extension methodmapReduce
to any type that extends or can be converted toIterable
. In our example, this includesString
.import scala.collection.{Iterable, IterableOps} import scala.collection.generic.IsIterable class ExtensionMethods[Repr, I <: IsIterable[Repr]](coll: Repr, it: I) { def mapReduce[B](mapper: it.A => B)(reducer: (B, B) => B): B = { val iter = it(coll).iterator var res = mapper(iter.next()) while (iter.hasNext) res = reducer(res, mapper(iter.next())) res } } implicit def withExtensions[Repr](coll: Repr)(implicit it: IsIterable[Repr]): ExtensionMethods[Repr, it.type] = new ExtensionMethods(coll, it) // See it in action! List(1, 2, 3).mapReduce(_ * 2)(_ + _) // res0: Int = 12 "Yeah, well, you know, that's just, like, your opinion, man.".mapReduce(x => 1)(_ + _) // res1: Int = 59
Here, we begin by creating a class
ExtensionMethods
which contains ourmapReduce
extension method.Note that
ExtensionMethods
takes a constructor argumentcoll
of typeRepr
, whereRepr
represents (typically) the collection type, and an argumentit
of a subtype ofIsIterable[Repr]
. The body of the method starts by converting thecoll
argument to anIterableOps
in order to call theiterator
method on it. The remaining of the implementation is straightforward.The
withExtensions
implicit conversion makes themapReduce
operation available on any typeRepr
for which it exists an implicitIsIterable[Repr]
instance. Note how we keep track of the precise type of the implicitit
argument by using theit.type
singleton type, rather than the widerIsIterable[Repr]
type. We do that so that the information carried by the type membersA
andC
of theit
argument is not lost.When the
mapReduce
method is called on some type of which it is not a member, implicit search is triggered. Because implicit conversionwithExtensions
is generic, it will be applied as long as an implicit value of typeIsIterable[Repr]
can be found. Given that theIsIterable
companion object contains implicit members that return values of typeIsIterable
, this requirement is typically satisfied, and the chain of interactions described in the previous paragraph is set into action. (See theIsIterable
companion object, which contains a precise specification of the available implicits.)Note: Currently, it's not possible to combine the implicit conversion and the class with the extension methods into an implicit class due to limitations of type inference.
Implementing
IsIterable
for New TypesOne must simply provide an implicit value of type
IsIterable
specific to the new type, or an implicit conversion which returns an instance ofIsIterable
specific to the new type.Below is an example of an implementation of the
IsIterable
trait where theRepr
type isRange
.implicit val rangeRepr: IsIterable[Range] { type A = Int; type C = IndexedSeq[Int] } = new IsIterable[Range] { type A = Int type C = IndexedSeq[Int] def apply(coll: Range): IterableOps[Int, IndexedSeq, IndexedSeq[Int]] = coll }
(Note that in practice the
IsIterable[Range]
instance is already provided by the standard library, and it is defined as anIsSeq[Range]
instance) - type member
- trait IsIterableLowPriority extends AnyRef
- trait IsIterableOnce[Repr] extends AnyRef
Type class witnessing that a collection representation type
Repr
has elements of typeA
and has a conversion toIterableOnce[A]
.Type class witnessing that a collection representation type
Repr
has elements of typeA
and has a conversion toIterableOnce[A]
.This type enables simple enrichment of
IterableOnce
s with extension methods which can make full use of the mechanics of the Scala collections framework in their implementation.Example usage,
class FilterMapImpl[Repr, I <: IsIterableOnce[Repr]](coll: Repr, it: I) { final def filterMap[B, That](f: it.A => Option[B])(implicit bf: BuildFrom[Repr, B, That]): That = { val b = bf.newBuilder(coll) for(e <- it(coll).iterator) f(e) foreach (b +=) b.result() } } implicit def filterMap[Repr](coll: Repr)(implicit it: IsIterableOnce[Repr]): FilterMapImpl[Repr, it.type] = new FilterMapImpl(coll, it) List(1, 2, 3, 4, 5) filterMap (i => if(i % 2 == 0) Some(i) else None) // == List(2, 4)
- trait IsIterableOnceLowPriority extends AnyRef
- trait IsMap[Repr] extends IsIterable[Repr]
Type class witnessing that a collection type
Repr
has keys of typeK
, values of typeV
and has a conversion toMapOps[K, V, Iterable, C]
, for some typesK
,V
andC
.Type class witnessing that a collection type
Repr
has keys of typeK
, values of typeV
and has a conversion toMapOps[K, V, Iterable, C]
, for some typesK
,V
andC
.This type enables simple enrichment of
Map
s with extension methods.- Repr
Collection type (e.g.
Map[Int, String]
)
- trait IsSeq[Repr] extends IsIterable[Repr]
Type class witnessing that a collection representation type
Repr
has elements of typeA
and has a conversion toSeqOps[A, Iterable, C]
, for some typesA
andC
.Type class witnessing that a collection representation type
Repr
has elements of typeA
and has a conversion toSeqOps[A, Iterable, C]
, for some typesA
andC
.This type enables simple enrichment of
Seq
s with extension methods which can make full use of the mechanics of the Scala collections framework in their implementation.
Deprecated Type Members
- type CanBuildFrom[-From, -A, +C] = BuildFrom[From, A, C]
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use scala.collection.BuildFrom instead
- type Clearable = mutable.Clearable
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Clearable was moved from collection.generic to collection.mutable
- type Growable[-A] = mutable.Growable[A]
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Growable was moved from collection.generic to collection.mutable
- type IsTraversableLike[Repr] = IsIterable[Repr]
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use IsIterable instead
- type IsTraversableOnce[Repr] = IsIterableOnce[Repr]
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use IsIterableOnce instead
- type Shrinkable[-A] = mutable.Shrinkable[A]
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Shrinkable was moved from collection.generic to collection.mutable
- trait Subtractable[A, +Repr <: Subtractable[A, Repr]] extends AnyRef
This trait represents collection-like objects that can be reduced using a '+' operator.
This trait represents collection-like objects that can be reduced using a '+' operator. It defines variants of
-
and--
as convenience methods in terms of single-element removal-
.- A
the type of the elements of the collection.
- Repr
the type of the collection itself
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Subtractable is deprecated. This is now implemented as part of SetOps, MapOps, etc.
Value Members
- object IsIterable extends IsIterableLowPriority
- object IsIterableOnce extends IsIterableOnceLowPriority
- object IsMap
- object IsSeq
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.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.collection.parallel
- Parallel collections (scala-parallel-collections.jar)scala.util.parsing
- Parser combinators (scala-parser-combinators.jar)scala.swing
- A convenient wrapper around Java's GUI framework called Swing (scala-swing.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
.