Add 'error' type and 'canon error.{new,debug-message,drop}' built-ins

Author: lukewagner

design/mvp/Async.md

@@ -232,11 +232,10 @@ f: func(x: whatever) -> stream<T>;
 g: func(s: stream<T>) -> stuff;
 ```
 `g(f(x))` works as you might hope, concurrently streaming `x` into `f` which
-concurrently streams its results into `g`. (The addition of [`error`](#TODO)
-will provide a generic answer to the question of what happens if `f`
-experiences an error: `f` can close its returned writable stream end with an
-`error` that will be propagated into `g` which should then propagate the error
-somehow into `stuff`.)
+concurrently streams its results into `g`. If `f` has an error, it can close
+its returned `stream<T>` with an [`error`](Explainer.md#error-type) value
+which `g` will receive along with the notification that its readable stream
+was closed.
 
 If a component instance *would* receive the readable end of a stream for which
 it already owns the writable end, the readable end disappears and the existing
@@ -518,7 +517,6 @@ For now, this remains a [TODO](#todo) and validation will reject `async`-lifted
 Native async support is being proposed incrementally. The following features
 will be added in future chunks roughly in the order list to complete the full
 "async" story:
-* add `error` type that can be included when closing a stream/future
 * `nonblocking` function type attribute: allow a function to declare in its
   type that it will not transitively do anything blocking
 * define what `async` means for `start` functions (top-level await + background

design/mvp/Binary.md

@@ -190,6 +190,7 @@ primvaltype   ::= 0x7f                                    => bool
                 | 0x75                                    => f64
                 | 0x74                                    => char
                 | 0x73                                    => string
+                | 0x64                                    => error
 defvaltype    ::= pvt:<primvaltype>                       => pvt
                 | 0x72 lt*:vec(<labelvaltype>)            => (record (field lt)*)    (if |lt*| > 0)
                 | 0x71 case*:vec(<case>)                  => (variant case+) (if |case*| > 0)
@@ -307,6 +308,9 @@ canon    ::= 0x00 0x00 f:<core:funcidx> opts:<opts> ft:<typeidx> => (canon lift
            | 0x19 async?:<async?>                                => (canon future.cancel-write async? (core func)) 🔀
            | 0x1a t:<typeidx>                                    => (canon future.close-readable t (core func)) 🔀
            | 0x1b t:<typeidx>                                    => (canon future.close-writable t (core func)) 🔀
+           | 0x1c opts:<opts>                                    => (canon error.new opts (core func)) 🔀
+           | 0x1d opts:<opts>                                    => (canon error.debug-message opts (core func)) 🔀
+           | 0x1e                                                => (canon error.drop (core func)) 🔀
 async?   ::= 0x00                                                =>
            | 0x01                                                => async
 opts     ::= opt*:vec(<canonopt>)                                => opt*
@@ -478,6 +482,7 @@ named once.
 
 ## Binary Format Warts to Fix in a 1.0 Release
 
+* The opcodes (for types, canon built-ins, etc) should be re-sorted
 * The two `list` type codes should be merged into one with an optional immediate.
 * The `0x00` prefix byte of `importname'` and `exportname'` will be removed or repurposed.