What is the best way to create and pass around dictionaries containing multiple types in scala?

Question

By dictionary I mean a lightweight map from names to values that can be used as the return value of a method.

Options that I'm aware of include making case classes, creating anon objects, and making maps from Strings -> Any.

Case classes require mental overhead to create (names), but are strongly typed.
Anon objects don't seem that well documented and it's unclear to me how to use them as arguments since there is no named type.
Maps from String -> Any require casting for retrieval.

Is there anything better?

Ideally these could be built from json and transformed back into it when appropriate.

I don't need static typing (though it would be nice, I can see how it would be impossible) - but I do want to avoid explicit casting.

What do you call a “lightweight map”? Is a `scala.collection.immutable.Map` heavyweight? — Jean-Philippe Pellet, Aug 02 '11 at 22:07
If something like [that answer](http://stackoverflow.com/questions/6584840/scala-map-containing-mix-type-values/6585202#6585202) would suit you, I can rewrite it to fit your question. — Jean-Philippe Pellet, Aug 03 '11 at 12:21

score 3 · Answer 1 · answered Aug 03 '11 at 00:11

Here's the fundamental problem with what you want:

def get(key: String): Option[T] = ...

val r = map.get("key")

The type of r will be defined from the return type of get -- so, what should that type be? From where could it be defined? If you make it a type parameter, then it's relatively easy:

import scala.collection.mutable.{Map => MMap}
val map: MMap[String, (Manifest[_], Any) = MMap.empty
def get[T : Manifest](key: String): Option[T] = map.get(key).filter(_._1 <:< manifest[T]).map(_._2.asInstanceOf[T])
def put[T : Manifest](key: String, obj: T) = map(key) = manifest[T] -> obj

Example:

scala> put("abc", 2)

scala> put("def", true)

scala> get[Boolean]("abc")
res2: Option[Boolean] = None

scala> get[Int]("abc")
res3: Option[Int] = Some(2)

The problem, of course, is that you have to tell the compiler what type you expect to be stored on the map under that key. Unfortunately, there is simply no way around that: the compiler cannot know what type will be stored under that key at compile time.

Any solution you take you'll end up with this same problem: somehow or other, you'll have to tell the compiler what type should be returned.

Now, this shouldn't be a burden in a Scala program. Take that r above... you'll then use that r for something, right? That something you are using it for will have methods appropriate to some type, and since you know what the methods are, then you must also know what the type of r must be.

If this isn't the case, then there's something fundamentally wrong with the code -- or, perhaps, you haven't progressed from wanting the map to knowing what you'll do with it.

That's pretty cool! But my ideal would be that I could `val b: Boolean = get("abc")` - so I don't need to explicitly specify the type or cast in the get call. Ideally if a method `foo` only takes bools, then `foo(get("abc"))` would also just work since the type system should figure out I can get a bool. If `foo` was ambiguous in what types it took as it's argument then I'm fine with specifying an explicit type. — wn-, Aug 03 '11 at 01:55
@wn- That won't work because `T` can, and will, be inferred to be `Nothing` -- after all, `Nothing` is subtype of everything, so `val b: Boolean = get[Nothing]("abc")` is perfectly valid. You might get it working if you add an implicit parameter to `get` than can be satisfied by any type except `Nothing` -- there's a recent question about this. — Daniel C. Sobral, Aug 03 '11 at 03:22

score 2 · Answer 2 · answered Aug 02 '11 at 21:10

So you want to parse json and turn it into objects that resemble the javascript objets described in the json input? If you want static typing, case classes are pretty much your only option and there are already libraries handling this, for example lift-json.

Another option is to use Scala 2.9's experimental support for dynamic typing. That will give you elegant syntax at the expense of type safety.

CheatEx · Answer 3 · 2011-08-09T07:32:46.337

You can use approach I've seen in the casbah library, when you explicitly pass a type parameter into the get method and cast the actual value inside the get method. Here is a quick example:

case class MultiTypeDictionary(m: Map[String, Any]) {
  def getAs[T <: Any](k: String)(implicit mf: Manifest[T]): T =
    cast(m.get(k).getOrElse {throw new IllegalArgumentException})(mf)

  private def cast[T <: Any : Manifest](a: Any): T =
    a.asInstanceOf[T]
}

implicit def map2multiTypeDictionary(m: Map[String, Any]) =
    MultiTypeDictionary(m)

val dict: MultiTypeDictionary = Map("1" -> 1, "2" -> 2.0, "3" -> "3")

val a: Int = dict.getAs("1")
val b: Int = dict.getAs("2") //ClassCastException
val b: Int = dict.getAs("4") //IllegalArgumetExcepton

You should note that there is no real compile-time checks, so you have to deal with all exceptions drawbacks.

UPD Working MultiTypeDictionary class

This is exactly what I want - but `val a`... gives `error: polymorphic expression cannot be instantiated to expected type;` on the repl. — wn-, Aug 04 '11 at 18:25

score 1 · Answer 4 · answered Aug 03 '11 at 07:25

If you have only a limited number of types which can occur as values, you can use some kind of union type (a.k.a. disjoint type), having e.g. a Map[Foo, Bar | Baz | Buz | Blargh]. If you have only two possibilities, you can use Either[A,B], giving you a Map[Foo, Either[Bar, Baz]]. For three types you might cheat and use Map[Foo, Either[Bar, Either[Baz,Buz]]], but this syntax obviously doesn't scale well. If you have more types you can use things like...

What is the best way to create and pass around dictionaries containing multiple types in scala?

4 Answers4

Linked