package generic
- Source
- package.scala
- Alphabetic
- By Inheritance
- generic
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
trait
IsIterableLike[Repr] extends AnyRef
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
)IsIterableLike
provides two members:- type member
A
, which represents the element type of the targetIterable[A]
- value member
conversion
, which provides a way to convert between the type we wish to add extension methods to,Repr
, andIterable[A]
.
Usage
One must provide
IsIterableLike
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 import scala.collection.generic.IsIterableLike class ExtensionMethods[A, Repr](coll: IterableLike[A, Repr]) { def mapReduce[B](mapper: A => B)(reducer: (B, B) => B): B = { val iter = coll.toIterator var res = mapper(iter.next()) while (iter.hasNext) res = reducer(res, mapper(iter.next())) res } } implicit def withExtensions[Repr](coll: Repr)(implicit Iterable: IsIterableLike[Repr]) = new ExtensionMethods(Iterable.conversion(coll)) // 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 thatExtensionMethods
takes a constructor argumentcoll
of typeIterableLike[A, Repr]
, whereA
represents the element type andRepr
represents (typically) the collection type. The implementation ofmapReduce
itself is straightforward.The interesting bit is the implicit conversion
withExtensions
, which returns an instance ofExtensionMethods
. This implicit conversion can only be applied if there is an implicit valueIterable
of typeIsIterableLike[Repr]
in scope. SinceIsIterableLike
provides value memberconversion
, which gives us a way to convert between whatever type we wish to add an extension method to (in this case,Repr
) andIterableLike[A, Repr]
, we can now convertcoll
from typeRepr
toIterableLike[A, Repr]
. This allows us to create an instance of theExtensionMethods
class, which we pass our newIterableLike[A, Repr]
to.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 typeIsIterableLike[Repr]
can be found. Given thatIsIterableLike
contains implicit members that return values of typeIsIterableLike
, this requirement is typically satisfied, and the chain of interactions described in the previous paragraph is set into action. (See theIsIterableLike
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
IsIterableLike
for New TypesOne must simply provide an implicit value of type
IsIterableLike
specific to the new type, or an implicit conversion which returns an instance ofIsIterableLike
specific to the new type.Below is an example of an implementation of the
IsIterableLike
trait where theRepr
type isString
.implicit val stringRepr: IsIterableLike[String] { type A = Char } = new IsIterableLike[String] { type A = Char val conversion = implicitly[String => IterableOps[Char, Any, String]] }
- type member
-
trait
IsSeqLike[Repr] extends AnyRef
Type class witnessing that a collection representation type
Repr
has elements of typeA
and has a conversion toSeqOps[A, Seq, Repr]
.Type class witnessing that a collection representation type
Repr
has elements of typeA
and has a conversion toSeqOps[A, Seq, Repr]
.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. -
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
Value Members
- object IsIterableLike
- object IsSeqLike
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
.