From: Nathaniel N. <na...@na...> - 2009-07-06 16:32:21
|
I was proposing union types as a way to get polymorphism for throws clauses. Futures could be written: interface Future[T,X]{X <: Throwable} { def force(): T throws X; } and used as: Future[int,IOException | MyException]; with the following subtyping rules: Ti <: T1 | ... | Tn forall i. T <: Ti ------------------- T <: T1 | ... | Ti [Forgive any errors here, I'm doing this from memory.] I wasn't proposing having variables of union type, just to use them for throws clauses and in generics, so haven't thought about tagged unions. Nate On Jul 6, 2009, at 5:36 PM, Igor Peshansky wrote: > Dave, > > You can obviously write a TaggedUnion (or a Variant) in X10 for any > given (fixed) set of types. I believe what Vijay was asking was how > does one write a *generic* TaggedUnion class in X10. > > Nate, what is the current state of the union types proposal? This > is yet another use case for them. Are we definitely not going to > do this here? > Igor > > Dave Cunningham <dc...@do...> wrote on 07/06/2009 01:47:12 AM: > >> * Vijay Saraswat (vi...@sa...) wrote: >>> how do you write a tagged union in X10..? >> >> This is what I had in mind: (I called it Variant instead. For a >> laugh. >> Or maybe because it's a shorter name than TaggedUnion) >> >> If o was an Object instead of a Value we would probably do .equals() >> instead of == >> >> Also, HashMap seems not to have an apply(k,v) method, although it >> does >> have a put(k,v) method. >> >> >> >> import x10.io.Console; >> import x10.util.HashMap; >> >> public class Variant { >> >> protected val kind: Int; >> protected var c: Char; public def this (v:Char) { this.c = v; >> this.kind = 0; } public static operator (v:Char) : Variant = new > Variant(v); >> protected var i: Int; public def this (v:Int) { this.i = v; >> this.kind = 1; } public static operator (v:Int) : Variant = new > Variant(v); >> protected var f: Float; public def this (v:Float) { this.f = v; >> this.kind = 2; } public static operator (v:Float) : Variant = new > Variant(v); >> protected var o: Value; public def this (v:Value) { this.o = v; >> this.kind = 3; } public static operator (v:Value) : Variant = new > Variant(v); >> >> public def equals (that:Ref) { >> if (this==that) return true; >> if (!(that instanceof Variant)) return false; >> val other = that as Variant; >> if (kind != other.kind) return false; >> switch (kind) { >> case 0: return c == other.c; >> case 1: return i == other.i; >> case 2: return f == other.f; >> case 3: return o == other.o; >> } >> assert false : "Kind value unrecognised"; >> return false; >> } >> >> public def hashCode () { >> switch (kind) { >> case 0: return c.hashCode(); >> case 1: return i.hashCode(); >> case 2: return f.hashCode(); >> case 3: return o.hashCode(); >> } >> assert false : "Kind value unrecognised"; >> return 0; >> } >> >> public def toString () { >> switch (kind) { >> case 0: return c.toString(); >> case 1: return i.toString(); >> case 2: return f.toString(); >> case 3: return o.toString(); >> } >> assert false : "Kind value unrecognised"; >> return ""; >> } >> >> public static def main (args : Rail[String]) { >> val map = new HashMap[Variant,Variant](); >> map.put(3, 3.0f); >> map.put(3.0f, "str"); >> map.put("str", 3); >> Console.OUT.println("map(3) == "+map(3)); >> Console.OUT.println("map(3.0f) == "+map(3.0f)); >> Console.OUT.println("map(\"str\") == "+map("str")); >> } >> } >> >> // vim: shiftwidth=4:tabstop=4:expandtab > -- > Igor Peshansky (note the spelling change!) > IBM T.J. Watson Research Center > XJ: No More Pain for XML's Gain (http://www.research.ibm.com/xj/) > X10: Parallel Productivity and Performance (http://x10.sf.net/) > > > ------------------------------------------------------------------------------ > _______________________________________________ > X10-core mailing list > X10...@li... > https://lists.sourceforge.net/lists/listinfo/x10-core |