Metaprogramming-ish Type Removal

Let me try a shorter question:

Given two types, A and B <: A, how can I find a minimal type C such
that B = A with C and A != B?

Essentially, I want "type R = B without A"

Any ideas?

Thanks,
David

On Fri, Feb 6, 2009 at 1:48 PM, David Hall wrote:
> Hi,
>
> I've been working on a class that can help give some amount of type
> safety for type->value maps. (That is, maps with types as keys.) It's
> not perfect yet, but I'm stuck on how to get "removing" a type to
> work.
>
> Here's what I've got so far:
>
> import scala.reflect.Manifest;
> import scala.collection.immutable._;
>
> // This ctor will be made private eventually.
> class Annotation[+T] (map: Map[Class[_],Any] forSome {type U}) {
> def get[U>:T](implicit m: Manifest[U]) =
> map.get(m.erasure).asInstanceOf[Option[U]];
>
> def apply[U>:T]()(implicit m: Manifest[U]) = get[U].get;
>
> def +[U](x: U)(implicit m: Manifest[U]) = new Annotation[T with
> U](map + (m.erasure->x))
>
> def remove[U>:T](implicit m: Manifest[U]) = Annotation.remove(this,
> map - m.erasure);
>
> override def toString = map.mkString("Annotation(",",",")");
> }
>
> object Annotation {
> def apply() = new Annotation[Any](Map.empty);
> def apply[T](x:T)(implicit m: Manifest[T]) = new
> Annotation[T](Map.empty + (m.erasure->x))
>
> // this method will be private too
> def remove[U,T >: R with U,R](anno: Annotation[T], map:
> Map[Class[_],Any])(implicit m: Manifest[U]) = new Annotation[R](map);
> }
>
> In the terminal, it looks like this:
>
> scala> import scalanlp.util._;
> import scalanlp.util._;
> import scalanlp.util._
>
> scala> val a = Annotation() + 3 + "4";
> val a = Annotation() + 3 + "4";
> a: scalanlp.util.Annotation[Any with Int with java.lang.String] =
> Annotation((int,3),(class java.lang.String,4))
>
> scala> a.get[Int];
> a.get[Int];
> res0: Option[Int] = Some(3)
>
> scala> a.get[Float];
> a.get[Float];
> :8: error: type arguments [Float] do not conform to method
> get's type parameter bounds [U >: Any with Int with java.lang.String]
> a.get[Float];
> ^
>
> But if I try to remove something, scala doesn't infer the lower bound
> I'd like (Any with String):
>
> scala> a.remove[Int];
> a.remove[Int];
> res1: scalanlp.util.Annotation[Nothing] = Annotation((class java.lang.String,4))
>
> If I call Annotation.remove directly with the correct arguments,
> things work fine.
>
> I then tried:
>
> // notice change in <:
> def remove[U,T <: R with U,R](annotation:Annotation[T], map:
> Map[Class[_],Any])(implicit m: Manifest[U]) = new Annotation[R](map);
>
> But then I get an error saying:
>
> inferred type arguments [U,T,Nothing] do not conform to method
> remove's type parameter bounds [U,T <: R with U,R] Annotation.scala
>
> Finally, I tried the implicit route:
>
> implicit def withRemoval[T,U](annotation: Annotation[T with U]) = new {
> def remove[R >: U <: U](implicit m: Manifest[U]) = new
> Annotation[T](annotation.map - m.erasure)
> }
>
> But that doesn't work:
>
> scala> a.remove[Int];
> a.remove[Int];
> :8: error: type arguments [Int] do not conform to method
> remove's type parameter bounds [R >: Any with Int with
> java.lang.String <: Any with Int with java.lang.String]
> a.remove[Int];
>
> Is this possible? Removal isn't entirely necessary, really, but it
> would be nice. Thanks for any help.
>