Расширение коллекции Scala - PullRequest
Новая
       15

Расширение коллекции Scala

5 голосов
/ 14 февраля 2010

Мне нужна карта, которая выдает при попытке перезаписать значение для существующего ключа. Я попробовал: 

trait Unoverwriteable[A, B] extends scala.collection.Map[A, B] {
    case class KeyAlreadyExistsException(e: String) extends Exception(e)

    abstract override def + [B1 >: B] (kv: (A, B1)): Unoverwriteable[A, B1] = {
        if (this contains(kv _1)) throw new KeyAlreadyExistsException(
            "key already exists in WritableOnce map: %s".format((kv _1) toString)
        )
        super.+(kv)
    }

    abstract override def get(key: A): Option[B] = super.get(key)
    abstract override def iterator: Iterator[(A, B)] = super.iterator
    abstract override def -(key: A): Unoverwriteable[A, B] = super.-(key)
}

и получил: 

<console>:11: error: type mismatch;
 found   : scala.collection.Map[A,B1]
 required: Unoverwirteable[A,B1]
               super.+(kv)
                      ^
<console>:16: error: type mismatch;
 found   : scala.collection.Map[A,B]
 required: Unoverwirteable[A,B]
           abstract override def -(key: A): Unoverwirteable[A, B] = super.-(key)
                                                                           ^

Я довольно новичок в Scala и не могу найти способ преодолеть это. Любая помощь? :)

edit: я использую Scala 2.8.0.Beta1-prerelease (который вносит некоторые изменения в scala.collection)

Ответы [ 3 ]

4 голосов
/ 14 февраля 2010

Это исправило вашу ошибку компиляции: 

trait Unoverwriteable[A, B] extends scala.collection.Map[A, B] {
    case class KeyAlreadyExistsException(e: String) extends Exception(e)

    abstract override def + [B1 >: B] (kv: (A, B1)): scala.collection.Map[A, B1] = {
        if (this contains(kv _1)) throw new KeyAlreadyExistsException(
            "key already exists in WritableOnce map: %s".format((kv _1) toString)
        )
        super.+[B1](kv)
    }

    abstract override def get(key: A): Option[B] = super.get(key)
    abstract override def iterator: Iterator[(A, B)] = super.iterator
    abstract override def -(key: A): scala.collection.Map[A, B] = super.-(key)
}

Однако, я думаю, вы действительно хотите украсить collection.mutable.Map#+= следующим образом: 

trait Unoverwriteable[A, B] extends collection.mutable.Map[A, B] {
  case class KeyAlreadyExistsException(e: String) extends Exception(e)

  abstract override def +=(kv: (A, B)): this.type = {
    if (this contains (kv _1))
      throw new KeyAlreadyExistsException("key already exists in WritableOnce map: %s".format((kv _1) toString))
    super.+=(kv)
  }
}
4 голосов
/ 14 февраля 2010

Поскольку вы переопределяете методы в Map, вы не можете определить свою черту как тип возврата.

Самое простое решение - просто пропустить типы: 

abstract override def + [B1 >: B] (kv: (A, B1)) = { /* ... */ }
// ...
abstract override def -(key: A) = super.-(key)

Или вы можете указать явный тип super: 

import scala.collection.Map
abstract override def +[B1 >: B] (kv: (A, B1)): Map[A, B1] = { /* ... */ }
// ...
abstract override def -(key: A) = super.-(key): Map[A, B]

Я думаю, вам нужно будет только переопределить +, поскольку другие ваши методы делегируют только Map.

3 голосов
/ 15 февраля 2010

Вы можете сделать это, используя scala.collection.immutable.Map с небольшой неявной магией. То есть вы определяете один дополнительный метод в интерфейсе и неявное преобразование. Вот как я это сделаю в 2.7, я уверен, что в 2.8 есть разные методы для переопределения, но вы должны понять общую идею. 

trait Unoverwriteable[A, B] extends scala.collection.immutable.Map[A, B] {
    import Unoverwriteable.unoverwriteableMap

    case class KeyAlreadyExistsException(e: String) extends Exception(e)

    def underlying: scala.collection.immutable.Map[A, B]

    def update [B1 >: B] (key: A, value: B1): Unoverwriteable[A, B1] = {
        if (this contains(key)) throw new KeyAlreadyExistsException(
            "key already exists in WritableOnce map: %s".format(key.toString)
        )
        underlying update (key, value)
    }

    def get(key: A): Option[B] = underlying get key 
    def elements: Iterator[(A, B)] = underlying.elements
    def -(key: A): Unoverwriteable[A,B] = underlying - key
    def empty[C]: Unoverwriteable[A,C] = underlying.empty[C]
    def size: Int = underlying.size
}

Затем вы определяете неявное в сопутствующем объекте: 

object Unoverwriteable {
   implicit def unoverwriteableMap[A, B](map0: scala.collection.immutable.Map[A, B]): Unoverwriteable[A, B] =
      new Unoverwriteable[A, B] { def underlying = map0 }

}

Чтобы использовать его, добавьте аннотацию типа Unwriteable на вашу карту. Если вы раскомментируете последние 2 строки в основном методе, вы получите KeyAlreadyExistsException по желанию. 

object UOMain {
   def main(args: Array[String]): Unit = {
      val map0 = Map((1 -> 1), (2 -> 2)): Unoverwriteable[Int, Int]
      println("map0="+ map0)

      val map1 = map0 - 2
      println("map1="+ map1)

      //val map2 = map1 + (1 -> 1000)
      //println("map2" + map2)
   }
}
...