tessl/maven-org-scala-lang-modules--scala-collection-compat

A library that makes some Scala 2.13 APIs available on Scala 2.11 and 2.12, facilitating cross-building Scala 2.13 and 3.0 code on older versions

—

Pending

Overview

Eval results

Files

Collection Factories

Name: tessl/maven-org-scala-lang-modules--scala-collection-compat
Author: tessl

The collection factory system provides a unified way to create collections across different Scala versions, abstracting away the differences between Scala 2.11/2.12 and 2.13/3.0.

Core Types

Factory Type Alias

type Factory[-A, +C] = CanBuildFrom[Nothing, A, C]

A factory that builds a collection of type C with elements of type A. On Scala 2.11/2.12, this is implemented as a type alias for CanBuildFrom. On Scala 2.13+, it aliases scala.collection.Factory.

BuildFrom Trait

trait BuildFrom[-From, -A, +C] extends Any {
  def fromSpecific(from: From)(it: IterableOnce[A]): C
  def newBuilder(from: From): mutable.Builder[A, C]
  
  @deprecated("Use newBuilder() instead of apply()", "2.13.0")
  @inline def apply(from: From): mutable.Builder[A, C] = newBuilder(from)
}

object BuildFrom {
  // Implicit instance derived from an implicit CanBuildFrom instance
  implicit def fromCanBuildFrom[From, A, C](
      implicit cbf: CanBuildFrom[From, A, C]): BuildFrom[From, A, C]
      
  // Implicit conversion derived from an implicit conversion to CanBuildFrom  
  implicit def fromCanBuildFromConversion[X, From, A, C](x: X)(
      implicit toCanBuildFrom: X => CanBuildFrom[From, A, C]): BuildFrom[From, A, C]
}

Builds a collection of type C from elements of type A when a source collection of type From is available. This trait bridges the API differences between Scala versions by providing automatic conversions from CanBuildFrom instances.

Extension Methods

FactoryOps

implicit class FactoryOps[-A, +C](private val factory: Factory[A, C]) {
  def fromSpecific(it: TraversableOnce[A]): C
  def newBuilder: mutable.Builder[A, C]
}

Extension methods for the Factory type:

fromSpecific: Create a collection from a TraversableOnce of elements
newBuilder: Get a new builder for the collection type

IterableFactoryExtensionMethods

implicit class IterableFactoryExtensionMethods[CC[X] <: GenTraversable[X]](
    private val fact: GenericCompanion[CC]) {
  def from[A](source: TraversableOnce[A]): CC[A]
}

Extension methods for generic collection companions.

MapFactoryExtensionMethods

implicit class MapFactoryExtensionMethods[CC[A, B] <: Map[A, B] with MapLike[A, B, CC[A, B]]](
    private val fact: MapFactory[CC]) {
  def from[K, V](source: TraversableOnce[(K, V)]): CC[K, V]
}

Extension methods for map factory companions.

BitSetFactoryExtensionMethods

implicit class BitSetFactoryExtensionMethods[C <: BitSet with BitSetLike[C]](
    private val fact: BitSetFactory[C]) {
  def fromSpecific(source: TraversableOnce[Int]): C
}

Extension methods for BitSet factory companions.

Collection-Specific Factory Extensions

Array Extensions

final class ArrayExtensions(private val fact: Array.type) extends AnyVal {
  def from[A: ClassTag](source: TraversableOnce[A]): Array[A]
}

Immutable Map Extensions

class ImmutableSortedMapExtensions(private val fact: immutable.SortedMap.type) extends AnyVal {
  def from[K: Ordering, V](source: TraversableOnce[(K, V)]): immutable.SortedMap[K, V]
}

class ImmutableListMapExtensions(private val fact: immutable.ListMap.type) extends AnyVal {
  def from[K, V](source: TraversableOnce[(K, V)]): immutable.ListMap[K, V]
}

class ImmutableHashMapExtensions(private val fact: immutable.HashMap.type) extends AnyVal {
  def from[K, V](source: TraversableOnce[(K, V)]): immutable.HashMap[K, V]
}

class ImmutableTreeMapExtensions(private val fact: immutable.TreeMap.type) extends AnyVal {
  def from[K: Ordering, V](source: TraversableOnce[(K, V)]): immutable.TreeMap[K, V]
}

class ImmutableIntMapExtensions(private val fact: immutable.IntMap.type) extends AnyVal {
  def from[V](source: TraversableOnce[(Int, V)]): immutable.IntMap[V]
}

class ImmutableLongMapExtensions(private val fact: immutable.LongMap.type) extends AnyVal {
  def from[V](source: TraversableOnce[(Long, V)]): immutable.LongMap[V]
}

Mutable Map Extensions

class MutableLongMapExtensions(private val fact: mutable.LongMap.type) extends AnyVal {
  def from[V](source: TraversableOnce[(Long, V)]): mutable.LongMap[V]
}

class MutableHashMapExtensions(private val fact: mutable.HashMap.type) extends AnyVal {
  def from[K, V](source: TraversableOnce[(K, V)]): mutable.HashMap[K, V]
}

class MutableListMapExtensions(private val fact: mutable.ListMap.type) extends AnyVal {
  def from[K, V](source: TraversableOnce[(K, V)]): mutable.ListMap[K, V]
}

class MutableMapExtensions(private val fact: mutable.Map.type) extends AnyVal {
  def from[K, V](source: TraversableOnce[(K, V)]): mutable.Map[K, V]
}

Usage Examples

Creating Collections from Iterables

import scala.collection.compat._

// Using factory extensions
val list = List.from(Array(1, 2, 3))
val set = Set.from(List(1, 2, 2, 3))
val map = Map.from(List("a" -> 1, "b" -> 2))

// Using Array extensions  
val array = Array.from(List(1, 2, 3))

// Using specialized map factories
val sortedMap = immutable.SortedMap.from(List("c" -> 3, "a" -> 1, "b" -> 2))
val hashMap = immutable.HashMap.from(List("x" -> 10, "y" -> 20))

Working with Builders

import scala.collection.compat._

// Get a builder from factory
val listFactory: Factory[Int, List[Int]] = implicitly
val builder = listFactory.newBuilder
builder += 1
builder += 2
val result = builder.result()  // List(1, 2)

// Use fromSpecific for direct creation
val list2 = listFactory.fromSpecific(Array(3, 4, 5))  // List(3, 4, 5)

Implementation Notes

On Scala 2.11/2.12, factories are implemented using CanBuildFrom
On Scala 2.13+, factories are type aliases to the native Factory type
The BuildFrom trait provides forward compatibility for the 2.13 API
Extension methods are added via implicit classes to avoid binary compatibility issues

Install with Tessl CLI

npx tessl i tessl/maven-org-scala-lang-modules--scala-collection-compat

docs

annotation-backports.md

backported-collections.md

collection-extensions.md

collection-factories.md

resource-management.md

string-parsing.md

tile.json

tessl/maven-org-scala-lang-modules--scala-collection-compat