Implementar una colección Scala de manera que un mapa, filtro, etc. producir el tipo correcto

Question

Estoy tratando de implementar un default valued map, y me gustaría filtros, mapas, etc. durante un DefaultingMap que también producen una DefaultingMap siempre que sea posible. Aquí está mi aplicación inicial:

class DefaultingMap[K, V](defaultValue: => V) 
extends mutable.HashMap[K, V] 
with mutable.MapLike[K, V, DefaultingMap[K, V]] { 

    override def empty = new DefaultingMap[K, V](defaultValue) 

    override def default(key: K): V = {     
    val result = this.defaultValue 
    this(key) = result 
    result            
    } 
} 

consigo objetos de tipo DefaultingMap cuando uso filter, pero no cuando se utiliza map:

scala> val counter = new DefaultingMap[Char, Int](0) 
counter: DefaultingMap[Char,Int] = Map() 

scala> for (c <- "ababcbbb") counter(c) += 1 

scala> counter.filter{case (k, v) => v > 1} 
res1: DefaultingMap[Char,Int] = Map((a,2), (b,5)) 

scala> counter.map{case (k, v) => (k, v * 2)} 
res2: scala.collection.mutable.HashMap[Char,Int] = Map((a,4), (c,2), (b,10)) 

La diferencia entre estos dos métodos parece ser que map toma una implícito CanBuildFrom. Así que deduzco que necesito tener un implicit def en algún lugar para proporcionar el CanBuildFrom. Mi primera intuición era hacer lo que se hace en HashMap:

object DefaultingMap extends generic.MutableMapFactory[DefaultingMap] { 

    def empty[K, V]: DefaultingMap[K, V] = // Not possible! 

    implicit def canBuildFrom[K, V]: 
    generic.CanBuildFrom[Coll, (K, V), DefaultingMap[K, V]] = 
     new MapCanBuildFrom[K, V] 
} 

Creo que esto sería que se compile, pero este método no funcionará porque es imposible definir el método empty - lo que necesita saber lo que el defaultValue debiera ser. Si pudiera definir el CanBuildFrom en la clase misma, en lugar del objeto complementario, estaría bien porque el defaultValue está disponible allí.

¿Cómo puedo hacer que funcione?

Answer 1

mapas son mutables Builder s en Scala, por lo que el MapFactory por defecto tiene un mapa vacío del tipo en cuestión para obtener un constructor.

Si tiene reglas de compilación de mapas personalizadas, una de las cosas que puede hacer es definir su fábrica personalizada similar a collection.generic.MapFactory. Tendría que definirlo de manera similar a como lo hace allí, pero haga que tanto el método empty como el método newBuilder tomen un argumento adicional para el defaultValue.

Algo a lo largo de las líneas (si se lee más sobre el API Scala 2,8 colecciones en el otro enlace sugerido, usted encontrará que usted no tiene que poner en práctica compañero genérica para los mapas):

import collection._                  


class DefaultingMap[K, V](val defaultValue: V)                  
extends mutable.HashMap[K, V]                      
with mutable.MapLike[K, V, DefaultingMap[K, V]] {                 

    override def empty = new DefaultingMap(defaultValue)                

}                             


object DefaultingMap {                        
    def newBuilder[K, V](d: V): DefaultingMap[K, V] = new DefaultingMap[K, V](d)          

    implicit def canBuildFrom[K, V] =                     
    new generic.CanBuildFrom[DefaultingMap[K, V], (K, V), DefaultingMap[K, V]] {          
     def apply(from: DefaultingMap[K, V]) = newBuilder[K, V](from.defaultValue)          
     def apply() = error("unsupported default apply")                
    }                            
}                             


object Main {                          
    def main(args: Array[String]) {                     
    println((new DefaultingMap[Int, Int](5)).defaultValue)               
    println(((new DefaultingMap[Int, Int](5)).map(x => x)).defaultValue)            
    }                             
} 

Lienzo:

$ scalac defaulting.scala 
$ scala Main 
5 
5 

admito, aún así, esto no resuelve el problema para el apply sin parámetros.

Answer 2

El Scala 2.8 Collections API es un documento muy agradable y me parece recordar que la discusión de este aspecto de la transformación, aunque no recuerdo exactamente dónde. Supongo que no es muy útil ...

Answer 3

Si utiliza collection.immutable.Map en 2,8 o superior, entonces el método withDefault está disponible para usted:

val m = collection.immutable.Map(1->"a", 2->"b", 3->"c") 
val n = m withDefaultValue "default" 

// n(7) will return "default" 

ACTUALIZACIÓN

Si' re mapeo sobre la colección, mueva el withDefaultValue hasta el final de la cadena de procesamiento:

val o = (for ((k, v) <- m) yield (k, v)) withDefaultValue "default" 
// o(0) will return "default" 

Answer 4

Ok, aquí es un enfoque que es muy, muy cerca de lo que quiero:

class DefaultingMap[K, V](defaultValue: => V) 
extends mutable.HashMap[K, V] 
with mutable.MapLike[K, V, DefaultingMap[K, V]] { 

    override def empty = new DefaultingMap[K, V](defaultValue) 

    override def default(key: K): V = {     
    val result = this.defaultValue 
    this(key) = result 
    result            
    } 

    implicit def canBuildFrom[NK] = 
    new generic.CanBuildFrom[DefaultingMap[K, V], (NK, V), DefaultingMap[NK, V]] { 
     def apply(from: DefaultingMap[K, V]) = 
     new DefaultingMap[NK, V](from.newDefaultValue) 
     def apply() = 
     new DefaultingMap[NK, V](defaultValue) 
    } 

    def newDefaultValue = defaultValue 
} 

Ahora, si consigo que CanBuildFrom en alcance, todo funciona como un encanto:

scala> val counter = new DefaultingMap[Char, Int](0) 
counter: DefaultingMap[Char,Int] = Map() 

scala> for (c <- "ababcbbb") counter(c) += 1 

scala> import counter._ 
import counter._ 

scala> counter.map{case (k, v) => (k, v * 2)} 
res1: DefaultingMap[Char,Int] = Map((a,4), (c,2), (b,10)) 

scala> for ((k, v) <- counter; if v > 1) yield (k.toString, v * 2) 
res2: DefaultingMap[java.lang.String,Int] = Map((a,4), (b,10)) 

Sin embargo, si dejo fuera de ese import counter._, obtengo el mismo comportamiento que antes. Si puedo encontrar la manera de encontrar ese implicit def canBuildFrom, me estableceré ...

Answer 5

No le ayudará con el tipo de devolución de map (pero de nuevo, el valor predeterminado del nuevo la recopilación generalmente no se puede definir utilizando la transformación map). Pero para darle otro enfoque:

class DefaultHashMap[A, B](dflt: => B) extends scala.collection.mutable.Map[A, B] { 
    val underlying = new scala.collection.mutable.HashMap[A, B]() 

    def get(key: A) = underlying.get(key) orElse Some(default(key)) 
    def iterator: Iterator[(A, B)] = underlying.iterator 
    def +=(kv: (A, B)) = { underlying += kv; this } 
    def -=(key: A) = { underlying -= key; this } 
    override def empty: DefaultHashMap[A, B] = new DefaultHashMap[A, B](dflt) 
    override def default(key: A) = dflt 
}