Maps

Author: julienrf

src/main/scala/strawman/collection/Iterable.scala

@@ -33,7 +33,7 @@ trait IterableLike[+A, +C[X] <: Iterable[X]]
  /** Create a collection of type `C[A]` from the elements of `coll`, which has
  * the same element type as this collection. Overridden in StringOps and ArrayOps.
  */
- protected[this] def fromIterableWithSameElemType(coll: Iterable[A]): C[A] = fromIterable(coll)
+ protected[this] def fromIterableWithSameElemType(coll: Iterable[A]): C[A]
 }
 
 /** Base trait for instances that can construct a collection from an iterable */

src/main/scala/strawman/collection/Map.scala

@@ -0,0 +1,44 @@
+package strawman.collection
+
+import strawman.collection.mutable.Builder
+
+import scala.Option
+import scala.annotation.unchecked.uncheckedVariance
+import scala.Predef.???
+
+/** Base Map type */
+trait Map[K, +V]
+ extends Iterable[(K, V)]
+ with MapLike[K, V, Map]
+
+/** Base Map implementation type */
+trait MapLike[K, +V, +C[X, Y] <: Map[X, Y]]
+ extends IterableLike[(K, V), Iterable]
+ with IterableMonoTransforms[(K, V), C[K, V @uncheckedVariance]]
+ with MapPolyTransforms[K, V, C] {
+
+ def get(key: K): Option[V]
+
+}
+
+/** Polymorphic transformation methods */
+trait MapPolyTransforms[K, +V, +C[X, Y] <: Map[X, Y]] extends IterablePolyTransforms[(K, V), Iterable] {
+
+ def map[K2, V2](f: (K, V) => (K2, V2)): C[K2, V2]
+
+ def flatMap[K2, V2](f: (K, V) => IterableOnce[(K2, V2)]): C[K2, V2]
+
+}
+
+/** Factory methods for collections of kind `* −> * -> *` */
+trait MapFactories[C[_, _]] {
+
+ def newBuilder[K, V]: Builder[(K, V), C[K, V]]
+
+ def empty[K, V]: C[K, V] =
+ newBuilder[K, V].result
+
+ def apply[K, V](elems: (K, V)*): C[K, V] =
+ newBuilder[K, V].++=(elems.toStrawman).result
+
+}

src/main/scala/strawman/collection/Seq.scala

@@ -50,8 +50,11 @@ trait IndexedSeq[+A] extends Seq[A] { self =>
 /** Base trait for Seq operations */
 trait SeqLike[+A, +C[X] <: Seq[X]]
  extends IterableLike[A, C]
- with SeqMonoTransforms[A, C[A @uncheckedVariance]] // sound bcs of VarianceNote
+ with SeqMonoTransforms[A, C[A @uncheckedVariance]] { // sound bcs of VarianceNote
 
+ protected[this] def fromIterableWithSameElemType(coll: Iterable[A]): C[A] = fromIterable(coll)
+
+}
 /** Base trait for linear Seq operations */
 trait LinearSeqLike[+A, +C[X] <: LinearSeq[X]] extends SeqLike[A, C] {
 

src/main/scala/strawman/collection/View.scala

@@ -12,6 +12,9 @@ trait View[+A] extends Iterable[A] with IterableLike[A, View] {
  case c: View[B] => c
  case _ => View.fromIterator(c.iterator())
  }
+
+ protected[this] def fromIterableWithSameElemType(coll: Iterable[A]): View[A] = fromIterable(coll)
+
  override def className = "View"
 }
 

src/main/scala/strawman/collection/mutable/HashMap.scala

@@ -0,0 +1,42 @@
+package strawman.collection.mutable
+
+import strawman.collection.{IterableOnce, Iterator, MapFactories}
+
+import scala.{Option, Unit}
+import scala.Predef.???
+
+/** A mutable map backed by a hashtable */
+final class HashMap[K, V]
+ extends Map[K, V]
+ with MapLike[K, V, HashMap] {
+
+ // From IterableOnce
+ def iterator(): Iterator[(K, V)] = ???
+
+ // From MapLike
+ def get(key: K): Option[V] = ???
+
+ // From Growable
+ def +=(elem: (K, V)): this.type = ???
+ def clear(): Unit = ???
+
+ // From mutable.MapLike
+ def -=(elem: (K, V)): this.type = ???
+ def put(key: K, value: V): Option[V] = ???
+
+ // From MapPolyTransforms
+ def map[K2, V2](f: (K, V) => (K2, V2)): HashMap[K2, V2] = ???
+ def flatMap[K2, V2](f: (K, V) => IterableOnce[(K2, V2)]): HashMap[K2, V2] = ???
+
+ // From IterablePolyTransforms
+ def fromIterable[B](coll: strawman.collection.Iterable[B]): Iterable[B] = ???
+ // From IterableMonoTransforms
+ protected[this] def fromIterableWithSameElemType(coll: strawman.collection.Iterable[(K, V)]): HashMap[K, V] = ???
+
+}
+
+object HashMap extends MapFactories[HashMap] {
+
+ def newBuilder[K, V]: Builder[(K, V), HashMap[K, V]] = ???
+
+}

src/main/scala/strawman/collection/mutable/Map.scala

@@ -0,0 +1,22 @@
+package strawman.collection.mutable
+
+import strawman.collection.IterableMonoTransforms
+
+import scala.Option
+
+/** Base type of mutable Maps */
+trait Map[K, V]
+ extends strawman.collection.Map[K, V]
+ with MapLike[K, V, Map]
+
+/** Base trait of mutable Maps implementations */
+trait MapLike[K, V, +C[X, Y] <: Map[X, Y]]
+ extends strawman.collection.MapLike[K, V, C]
+ with Iterable[(K, V)]
+ with Growable[(K, V)] {
+
+ def -= (elem: (K, V)): this.type
+
+ def put(key: K, value: V): Option[V]
+
+}

src/test/scala/strawman/collection/test/Test.scala

@@ -130,7 +130,7 @@ class StrawmanTest {
  val ys9: Seq[Int] = xs9
  val xs9a = xs.map(_.toUpper)
  val ys9a: String = xs9a
- val xs10 = xs.flatMap((x: Char) => s"$x,$x")
+ val xs10 = xs.flatMap(x => s"$x,$x")
  val ys10: String = xs10
  val xs11 = xs ++ xs
  val ys11: String = xs11
@@ -288,6 +288,15 @@ class StrawmanTest {
  println(xs17.to(List))
  }
 
+ def mapOps(xs: strawman.collection.Map[Int, String]): Unit = {
+ // val xs1 = xs.map { case (k, v) => (v, k) }
+ // val xs2: strawman.collection.Map[String, Int] = xs1
+ val xs1 = xs.map(kv => (kv._2, kv._1))
+ val xs2: strawman.collection.Iterable[(String, Int)] = xs1
+ println(xs1)
+ println(xs2)
+ }
+
  @Test
  def mainTest: Unit = {
  val ints = List(1, 2, 3)