Remove 'union' types (#237)

Author: lann

design/mvp/Binary.md

@@ -202,7 +202,6 @@ defvaltype    ::= pvt:<primvaltype>                       => pvt
                 | 0x6f t*:vec(<valtype>)                  => (tuple t+)    (if |t*| > 0)
                 | 0x6e l*:vec(<label>)                    => (flags l+)    (if |l*| > 0)
                 | 0x6d l*:vec(<label>)                    => (enum l*)
-                | 0x6c t*:vec(<valtype>)                  => (union t*)
                 | 0x6b t:<valtype>                        => (option t)
                 | 0x6a t?:<valtype>? u?:<valtype>?        => (result t? (error u)?)
                 | 0x69 i:<typeidx>                        => (own i)

design/mvp/CanonicalABI.md

@@ -74,7 +74,6 @@ function to replace specialized value types with their expansion:
 def despecialize(t):
   match t:
     case Tuple(ts)         : return Record([ Field(str(i), t) for i,t in enumerate(ts) ])
-    case Union(ts)         : return Variant([ Case(str(i), t) for i,t in enumerate(ts) ])
     case Enum(labels)      : return Variant([ Case(l, None) for l in labels ])
     case Option(t)         : return Variant([ Case("none", None), Case("some", t) ])
     case Result(ok, error) : return Variant([ Case("ok", ok), Case("error", error) ])

design/mvp/Explainer.md

@@ -493,7 +493,6 @@ defvaltype    ::= bool
                 | (tuple <valtype>+)
                 | (flags <label>+)
                 | (enum <label>+)
-                | (union <valtype>+)
                 | (option <valtype>)
                 | (result <valtype>? (error <valtype>)?)
                 | (own <typeidx>)
@@ -588,7 +587,6 @@ defined by the following mapping:
                       (flags <label>*) ↦ (record (field <label> bool)*)
                        (enum <label>+) ↦ (variant (case <label>)+)
                     (option <valtype>) ↦ (variant (case "none") (case "some" <valtype>))
-                    (union <valtype>+) ↦ (variant (case "𝒊" <valtype>)+) for 𝒊=0,1,...
 (result <valtype>? (error <valtype>)?) ↦ (variant (case "ok" <valtype>?) (case "error" <valtype>?))
                                 string ↦ (list char)
 ```
@@ -1666,7 +1664,6 @@ At a high level, the additional coercions would be:
 | `flags` | TBD: maybe a [JS Record]? | same as [`dictionary`] of optional `boolean` fields with default values of `false` |
 | `enum` | same as [`enum`] | same as [`enum`] |
 | `option` | same as [`T?`] | same as [`T?`] |
-| `union` | same as [`union`] | same as [`union`] |
 | `result` | same as `variant`, but coerce a top-level `error` return value to a thrown exception | same as `variant`, but coerce uncaught exceptions to top-level `error` return values |
 | `own`, `borrow` | see below | see below |
 
@@ -1682,7 +1679,7 @@ Notes:
   would need to define its own custom binding built from objects. As a sketch,
   the JS values accepted by `(variant (case "a" u32) (case "b" string))` could
   include `{ tag: 'a', value: 42 }` and `{ tag: 'b', value: "hi" }`.
-* For `union` and `option`, when Web IDL doesn't support particular type
+* For `option`, when Web IDL doesn't support particular type
   combinations (e.g., `(option (option u32))`), the JS API would fall back to
   the JS API of the unspecialized `variant` (e.g.,
   `(variant (case "some" (option u32)) (case "none"))`, despecializing only
@@ -1838,7 +1835,6 @@ and will be added over the coming months to complete the MVP proposal:
 [`dictionary`]: https://webidl.spec.whatwg.org/#es-dictionary
 [`enum`]: https://webidl.spec.whatwg.org/#es-enumeration
 [`T?`]: https://webidl.spec.whatwg.org/#es-nullable-type
-[`union`]: https://webidl.spec.whatwg.org/#es-union
 [`Get`]: https://tc39.es/ecma262/#sec-get-o-p
 [JS NaN]: https://tc39.es/ecma262/#sec-ecmascript-language-types-number-type
 [Import Reflection]: https://github.com/tc39-transfer/proposal-import-reflection

design/mvp/Subtyping.md

@@ -16,7 +16,6 @@ But roughly speaking:
 | `tuple`                   | `(tuple T ...) <: T` |
 | `option`                  | `T <: (option T)` |
 | `result`                  | `T <: (result T _)` |
-| `union`                   | `T <: (union ... T ...)` |
 | `own`, `borrow`           | none (although resource subtyping may be introduced in the future which would imply handle subtyping) |
 | `func`                    | parameter names must match in order; contravariant parameter subtyping; superfluous parameters can be ignored in the subtype; `option` parameters can be ignored in the supertype; covariant result subtyping |
 | `component`               | all imports in the subtype must be present in the supertype with matching types; all exports in the supertype must be present in the subtype |

design/mvp/WIT.md

@@ -712,14 +712,6 @@ interface foo {
     too-slow,
   }
 
-  // similar to `variant`, but doesn't require naming cases and all variants
-  // have a type payload -- note that this is not a C union, it still has a
-  // discriminant
-  union input {
-    u64,
-    string,
-  }
-
   // a bitflags type
   flags permissions {
     read,
@@ -742,7 +734,7 @@ interface foo {
 }
 ```
 
-The `record`, `variant`, `enum`, `union`, and `flags` types must all have names
+The `record`, `variant`, `enum`, and `flags` types must all have names
 associated with them. The `list`, `option`, `result`, `tuple`, and primitive
 types do not need a name and can be mentioned in any context. This restriction
 is in place to assist with code generation in all languages to leverage
@@ -839,7 +831,6 @@ keyword ::= 'use'
           | 'enum'
           | 'flags'
           | 'variant'
-          | 'union'
           | 'static'
           | 'interface'
           | 'world'
@@ -964,7 +955,6 @@ interface-items ::= typedef-item
 typedef-item ::= resource-item
                | variant-items
                | record-item
-               | union-items
                | flags-items
                | enum-items
                | type-item
@@ -1143,29 +1133,6 @@ enum-cases ::= id
              | id ',' enum-cases?
 ```
 
-### Item: `union` (variant but with no case names)
-
-A `union` statement defines a new type which is semantically equivalent to a
-`variant` where all of the cases have a payload type and the case names are
-numerical. This is special-cased, however, to have a different representation
-in the language ABIs or have different bindings generated in for languages.
-
-```wit
-union configuration {
-    string,
-    list<string>,
-}
-```
-
-Specifically the structure of this is:
-
-```ebnf
-union-items ::= 'union' id '{' union-cases '}'
-
-union-cases ::= ty
-              | ty ',' union-cases?
-```
-
 ### Item: `resource`
 
 A `resource` statement defines a new abstract type for a *resource*, which is

design/mvp/canonical-abi/definitions.py

@@ -141,10 +141,6 @@ class Variant(ValType):
 class Enum(ValType):
   labels: [str]
 
-@dataclass
-class Union(ValType):
-  ts: [ValType]
-
 @dataclass
 class Option(ValType):
   t: ValType
@@ -171,7 +167,6 @@ class Borrow(ValType):
 def despecialize(t):
   match t:
     case Tuple(ts)         : return Record([ Field(str(i), t) for i,t in enumerate(ts) ])
-    case Union(ts)         : return Variant([ Case(str(i), t) for i,t in enumerate(ts) ])
     case Enum(labels)      : return Variant([ Case(l, None) for l in labels ])
     case Option(t)         : return Variant([ Case("none", None), Case("some", t) ])
     case Result(ok, error) : return Variant([ Case("ok", ok), Case("error", error) ])

design/mvp/canonical-abi/run_tests.py

@@ -114,25 +114,6 @@ def test_name():
 test(t, [0,256], {'x': 0})
 test(t, [1,0x4048f5c3], {'y': 3.140000104904175})
 test(t, [2,0xffffffff], {'z': None})
-t = Union([U32(),U64()])
-test(t, [0,42], {'0':42})
-test(t, [0,(1<<35)], {'0':0})
-test(t, [1,(1<<35)], {'1':(1<<35)})
-t = Union([Float32(), U64()])
-test(t, [0,0x4048f5c3], {'0': 3.140000104904175})
-test(t, [0,(1<<35)], {'0': 0})
-test(t, [1,(1<<35)], {'1': (1<<35)})
-t = Union([Float64(), U64()])
-test(t, [0,0x40091EB851EB851F], {'0': 3.14})
-test(t, [0,(1<<35)], {'0': 1.69759663277e-313})
-test(t, [1,(1<<35)], {'1': (1<<35)})
-t = Union([U8()])
-test(t, [0,42], {'0':42})
-test(t, [1,256], None)
-test(t, [0,256], {'0':0})
-t = Union([Tuple([U8(),Float32()]), U64()])
-test(t, [0,42,3.14], {'0': {'0':42, '1':3.14}})
-test(t, [1,(1<<35),0], {'1': (1<<35)})
 t = Option(Float32())
 test(t, [0,3.14], {'none':None})
 test(t, [1,3.14], {'some':3.14})
@@ -279,16 +260,6 @@ def test_heap(t, expect, args, byte_array):
           [6,0, 7, 0x0ff, 8,0, 9, 0xff])
 test_heap(List(Tuple([Tuple([U16(),U8()]),U8()])), [mk_tup([4,5],6),mk_tup([7,8],9)], [0,2],
           [4,0, 5,0xff, 6,0xff,  7,0, 8,0xff, 9,0xff])
-# Empty record types are not permitted yet.
-#test_heap(List(Union([Record([]),U8(),Tuple([U8(),U16()])])), [{'0':{}}, {'1':42}, {'2':mk_tup(6,7)}], [0,3],
-#          [0,0xff,0xff,0xff,0xff,0xff,  1,0xff,42,0xff,0xff,0xff,  2,0xff,6,0xff,7,0])
-test_heap(List(Union([U32(),U8()])), [{'0':256}, {'1':42}], [0,2],
-          [0,0xff,0xff,0xff,0,1,0,0,  1,0xff,0xff,0xff,42,0xff,0xff,0xff])
-test_heap(List(Tuple([Union([U8(),Tuple([U16(),U8()])]),U8()])),
-          [mk_tup({'1':mk_tup(5,6)},7),mk_tup({'0':8},9)], [0,2],
-          [1,0xff,5,0,6,0xff,7,0xff,  0,0xff,8,0xff,0xff,0xff,9,0xff])
-test_heap(List(Union([U8()])), [{'0':6},{'0':7},{'0':8}], [0,3],
-          [0,6, 0,7, 0,8])
 # Empty flags types are not permitted yet.
 #t = List(Flags([]))
 #test_heap(t, [{},{},{}], [0,3],