17

我需要一个 Map，在其中放置不同类型的值（Double、String、Int、...），键可以是 String。

有没有办法做到这一点，这样我就可以得到正确的map.apply(k)类型

val map: Map[String, SomeType] = Map()
val d: Double = map.apply("double")
val str: String = map.apply("string")

我已经尝试过使用泛型类型

class Container[T](element: T) {
    def get: T = element
}

val d: Container[Double] = new Container(4.0)
val str: Container[String] = new Container("string")
val m: Map[String, Container] = Map("double" -> d, "string" -> str)

但这是不可能的，因为Container需要一个参数。有什么解决办法吗？

4

7 回答 7

22

这并不简单。

值的类型取决于键。所以键必须携带关于它的值是什么类型的信息。这是一种常见的模式。例如，它用于 SBT（参见SettingsKey[T]）和无形记录（Example）。然而，在 SBT 中，键是一个巨大的、复杂的类层次结构，而 shapeless 中的 HList 非常复杂，而且比你想要的要多。

所以这里有一个小例子，说明如何实现这一点。键知道类型，创建记录或从记录中获取值的唯一方法是键。我们在内部使用 Map[Key, Any] 作为存储，但转换是隐藏的并保证成功。有一个运算符用于从键创建记录，还有一个运算符用于合并记录。我选择了运算符，这样您就可以连接记录而不必使用括号。

sealed trait Record {

  def apply[T](key:Key[T]) : T

  def get[T](key:Key[T]) : Option[T]

  def ++ (that:Record) : Record
}

private class RecordImpl(private val inner:Map[Key[_], Any]) extends Record {

  def apply[T](key:Key[T]) : T = inner.apply(key).asInstanceOf[T]

  def get[T](key:Key[T]) : Option[T] = inner.get(key).asInstanceOf[Option[T]]

  def ++ (that:Record) = that match {
    case that:RecordImpl => new RecordImpl(this.inner ++ that.inner)
  }
}

final class Key[T] {
  def ~>(value:T) : Record = new RecordImpl(Map(this -> value))
}

object Key {

  def apply[T] = new Key[T]
}

这是您将如何使用它的方法。首先定义一些键：

val a = Key[Int]
val b = Key[String]
val c = Key[Float]

然后使用它们创建记录

val record = a ~> 1 ++ b ~> "abc" ++ c ~> 1.0f

使用键访问记录时，您将返回正确类型的值

scala> record(a)
res0: Int = 1

scala> record(b)
res1: String = abc

scala> record(c)
res2: Float = 1.0

我发现这种数据结构非常有用。有时您需要比案例类提供的更多灵活性，但您不想求助于完全类型不安全的东西，例如 Map[String,Any]。这是一个很好的中间立场。

编辑：另一种选择是有一个使用 (name, type) 对作为内部真正键的映射。获取值时必须提供名称和类型。如果您选择了错误的类型，则没有条目。然而，这有很大的潜在错误，比如当你输入一个字节并试图取出一个 int 时。所以我认为这不是一个好主意。

import reflect.runtime.universe.TypeTag

class TypedMap[K](val inner:Map[(K, TypeTag[_]), Any]) extends AnyVal {
  def updated[V](key:K, value:V)(implicit tag:TypeTag[V]) = new TypedMap[K](inner + ((key, tag) -> value))

  def apply[V](key:K)(implicit tag:TypeTag[V]) = inner.apply((key, tag)).asInstanceOf[V]

  def get[V](key:K)(implicit tag:TypeTag[V]) = inner.get((key, tag)).asInstanceOf[Option[V]]
}

object TypedMap {
  def empty[K] = new TypedMap[K](Map.empty)
}

用法：

scala> val x = TypedMap.empty[String].updated("a", 1).updated("b", "a string")
x: TypedMap[String] = TypedMap@30e1a76d

scala> x.apply[Int]("a")
res0: Int = 1

scala> x.apply[String]("b")
res1: String = a string

// this is what happens when you try to get something out with the wrong type.
scala> x.apply[Int]("b")
java.util.NoSuchElementException: key not found: (b,Int)
于 2013-07-16T20:08:04.780 回答
17

这现在在无形中非常简单，

scala> import shapeless._ ; import syntax.singleton._ ; import record._
import shapeless._
import syntax.singleton._
import record._

scala> val map = ("double" ->> 4.0) :: ("string" ->> "foo") :: HNil
map: ... <complex type elided> ... = 4.0 :: foo :: HNil

scala> map("double")
res0: Double with shapeless.record.KeyTag[String("double")] = 4.0

scala> map("string")
res1: String with shapeless.record.KeyTag[String("string")] = foo

scala> map("double")+1.0
res2: Double = 5.0

scala> val map2 = map.updateWith("double")(_+1.0)
map2: ... <complex type elided> ... = 5.0 :: foo :: HNil

scala> map2("double")
res3: Double = 5.0

截至本答案发布之日，这是无形的 2.0.0-SNAPSHOT 。

于 2013-08-17T10:40:15.990 回答
4

我终于找到了自己的解决方案，在我的情况下效果最好：

case class Container[+T](element: T) {
    def get[T]: T = {
        element.asInstanceOf[T]
    }
}

val map: Map[String, Container[Any]] = Map("a" -> Container[Double](4.0), "b" -> Container[String]("test"))
val double: Double = map.apply("a").get[Double]
val string: String = map.apply("b").get[String]
于 2013-07-17T17:01:26.080 回答
3

(a) Scala 容器不跟踪放置在其中的内容的类型信息，并且

String(b)对于要应用该方法的对象的给定实例，具有简单参数/键的应用/获取方法的返回“类型”将是静态的。

这感觉就像一个需要重新考虑的设计决策。

于 2013-07-16T18:19:39.373 回答
2

我不认为有一种方法可以赤裸裸map.apply()地做你想做的事。正如其他答案所暗示的那样，某种容器类将是必要的。这是一个将值限制为仅某些类型（在本例中为 String、Double、Int）的示例：

sealed trait MapVal
case class StringMapVal(value: String) extends MapVal
case class DoubleMapVal(value: Double) extends MapVal
case class IntMapVal(value: Int) extends MapVal

val myMap: Map[String, MapVal] =                                                               
  Map("key1" -> StringMapVal("value1"),
      "key2" -> DoubleMapVal(3.14),
      "key3" -> IntMapVal(42))

myMap.keys.foreach { k =>
  val message =
    myMap(k) match { // map.apply() in your example code
      case StringMapVal(x) => "string: %s".format(x)
      case DoubleMapVal(x) => "double: %.2f".format(x)
      case IntMapVal(x) => "int: %d".format(x)
    }
  println(message)
}

的主要好处sealted trait是编译时检查模式匹配中的非详尽匹配。

我也喜欢这种方法，因为按照 Scala 标准它相对简单。你可以去寻找更强大的东西，但在我看来，你很快就会陷入收益递减。

于 2013-07-16T19:01:47.653 回答
1

如果你想这样做，你必须指定Containerto be的类型Any，因为Any它是Doubleand的超类型String。 

val d: Container[Any] = new Container(4.0)
val str: Container[Any] = new Container("string")
val m: Map[String, Container[Any]] = Map("double" -> d, "string" -> str)

或者为了使事情更容易，您可以更改 的定义Container，使其不再是类型不变的：

class Container[+T](element: T) {
  def get: T = element
  override def toString = s"Container($element)"
}

val d: Container[Double] = new Container(4.0)
val str: Container[String] = new Container("string")
val m: Map[String, Container[Any]] = Map("double" -> d, "string" -> str)
于 2013-07-16T18:52:26.997 回答
1

有一种方法，但它很复杂。请参阅Scala 中的未装箱联合类型。本质上，您必须键入Map某种类型Int |v| Double才能同时保存Int和Double。您还将在编译时间上付出高昂的代价。

于 2013-07-16T19:09:30.467 回答