scala.collection.generic
Members list
Type members
Classlikes
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 chooseiterableFactory,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.
Attributes
- Source
- DefaultSerializationProxy.scala
- Supertypes
- Known subtypes
- classHashSet[A]classList[A]class::[A]objectNilclassListSet[A]classQueue[A]classTreeSet[A]classVector[A]classArrayBuffer[A]classArrayDeque[A]classQueue[A]classStack[A]classLinkedHashSet[A]classListBuffer[A]classTreeSet[A]classUnrolledBuffer[T]Show all
- Self type
- Iterable[_]
The default serialization proxy for collection implementations.
The default serialization proxy for collection implementations.
This class isfinal 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.
Attributes
- Source
- DefaultSerializationProxy.scala
- Supertypes
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 extendingIterable) 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 extendingIterable) 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 onStrings (Strings do not extendIterable, but can be converted toIterable)
IsIterable provides three members:
1. type memberA, which represents the element type of the targetIterable[A] 1. type memberC, which represents the type returned by transformation operations that preserve the collection’s elements type 1. methodapply, which provides a way to convert between the type we wish to add extension methods to,Repr, andIterableOps[A, Iterable, C].
Usage
One must provideIsIterable 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 = 59Here, we begin by creating a classExtensionMethods which contains ourmapReduce extension method.
Note thatExtensionMethods 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.
ThewithExtensions 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 themapReduce 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.
ImplementingIsIterable for New Types
One must simply provide an implicit value of typeIsIterable 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 theIsIterable 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 theIsIterable[Range] instance is already provided by the standard library, and it is defined as anIsSeq[Range] instance)
Attributes
- Companion
- object
- Source
- IsIterable.scala
- Supertypes
- Known subtypes
Attributes
- Companion
- trait
- Source
- IsIterable.scala
- Supertypes
- Self type
- IsIterable.type
Attributes
- Source
- IsIterable.scala
- Supertypes
- Known subtypes
- objectIsIterable
Type class witnessing that a collection representation typeRepr has elements of typeA and has a conversion toIterableOnce[A].
Type class witnessing that a collection representation typeRepr has elements of typeA and has a conversion toIterableOnce[A].
This type enables simple enrichment ofIterableOnces 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)Attributes
- Companion
- object
- Source
- IsIterableOnce.scala
- Supertypes
- Known subtypes
Attributes
- Companion
- trait
- Source
- IsIterableOnce.scala
- Supertypes
- Self type
- IsIterableOnce.type
Attributes
- Source
- IsIterableOnce.scala
- Supertypes
- Known subtypes
- objectIsIterableOnce
Type class witnessing that a collection typeRepr 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 typeRepr 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 ofMaps with extension methods.
Type parameters
- Repr
Collection type (e.g.
Map[Int, String])
Attributes
- See also
- Companion
- object
- Source
- IsMap.scala
- Supertypes
Type class witnessing that a collection representation typeRepr has elements of typeA and has a conversion toSeqOps[A, Iterable, C], for some typesA andC.
Type class witnessing that a collection representation typeRepr has elements of typeA and has a conversion toSeqOps[A, Iterable, C], for some typesA andC.
This type enables simple enrichment ofSeqs with extension methods which can make full use of the mechanics of the Scala collections framework in their implementation.
Attributes
- See also
- Companion
- object
- Source
- IsSeq.scala
- Supertypes
Deprecated classlikes
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-.
Type parameters
- A
the type of the elements of the $coll.
- Repr
the type of the $coll itself
Attributes
- Deprecated
[Since version 2.13.0]Subtractable is deprecated. This is now implemented as part of SetOps, MapOps, etc.- Source
- Subtractable.scala
- Supertypes
- Self type
Deprecated types
Attributes
- Deprecated
[Since version 2.13.0]Use scala.collection.BuildFrom instead- Source
- package.scala
Attributes
- Deprecated
[Since version 2.13.0]Clearable was moved from collection.generic to collection.mutable- Source
- package.scala
Attributes
- Deprecated
[Since version 2.13.0]Growable was moved from collection.generic to collection.mutable- Source
- package.scala
Attributes
- Deprecated
[Since version 2.13.0]Use IsIterable instead- Source
- package.scala
Attributes
- Deprecated
[Since version 2.13.0]Use IsIterableOnce instead- Source
- package.scala
Attributes
- Deprecated
[Since version 2.13.0]Shrinkable was moved from collection.generic to collection.mutable- Source
- package.scala