Don't wait unnecessarily.

corelib/src/implementation/promise_implementation.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // Dart core library.
 
 class PromiseImpl<T> implements Promise<T> {
 
   // Enumeration of possible states:
   static final int CREATED = 0;
@@ skipping 244 matching lines @@
     addCompleteHandler((val) {
       promises.forEach((promise) {
         if (!promise.isDone()) {
           promise.cancel();
         }
       });
     });
   }
 }
 
-class ProxyBase {
+// For now, extend Promise<bool> rather than either
+// a) create a new base, Completable, for Promise and Proxy, or
+// b) extend Promise<SendPort> which would expose the port.
+class ProxyBase extends PromiseImpl<bool> {
 
   ProxyBase.forPort(SendPort port) {
     _promise = new Promise<SendPort>();
     _promise.complete(port);
+    complete(true);
   }
 
   // Construct a proxy for a message reply; see the [Proxy.forReply]
   // documentation for more details.
   ProxyBase.forReply(Promise<SendPort> port) {
     _promise = port;
+    port.addCompleteHandler((_) => complete(true));
   }
 
-  // Note that comparing proxies or using them in maps is illegal
-  // until they complete.
+  // Note that comparing proxies or using them in maps or sets is
+  // illegal until they complete.
   bool operator ==(var other) {
     return (other is ProxyBase) && _promise.value == other._promise.value;
   }
 
   int hashCode() => _promise.value.hashCode();
 
-  // TODO: consider making this extend Promise<SendPort> instead?
-  void addCompleteHandler(void completeHandler()) {
-    _promise.addCompleteHandler((_) => completeHandler());
-  }
-
   static ReceivePort register(Dispatcher dispatcher) {
     if (_dispatchers === null) {
       _dispatchers = new Map<SendPort, Dispatcher>();
     }
     ReceivePort result = new ReceivePort();
     _dispatchers[result.toSendPort()] = dispatcher;
     return result;
   }
 
   get local() {
@@ skipping 24 matching lines @@
         result.complete(message[0]);
       });
       return result;
     });
   }
 
   // Marshal the [message] and pass it to the [process] callback
   // function. Any promises are converted to a port which expects to
   // receive a port from the other side down which the remote promise
   // can be completed by sending the promise's completion value.
-   Promise _marshal(List message, process(List marshalled)) {
+  Promise _marshal(List message, process(List marshalled)) {
     return _promise.then((SendPort port) {
       List marshalled = new List(message.length);
 
       for (int i = 0; i < marshalled.length; i++) {
         var entry = message[i];
         if (entry is Proxy) {
           entry = entry._promise;
         }
         // Obviously this will be true if [entry] was a Proxy.
         if (entry is Promise) {
           // Note that we could optimise this by just sending the value
           // if the promise is already complete. Let's get this working
           // first!
 
           // This port will receive a SendPort that can be used to
           // signal completion of this promise to the corresponding
           // promise that the other end has created.
           ReceivePort receiveCompleter = new ReceivePort.singleShot();
           marshalled[i] = receiveCompleter.toSendPort();
           Promise<SendPort> completer = new Promise<SendPort>();
           receiveCompleter.receive((var msg, SendPort replyPort) {
             completer.complete(msg[0]);
           });
           entry.addCompleteHandler((value) {
             completer.addCompleteHandler((SendPort port) {
-              port.send([value], null);
+              _marshal([value], (List message) => port.send(message, null));
             });
           });
         } else {
           // FIXME(kasperl, benl): this should probably be a copy?
           marshalled[i] = entry;
         }
         if (marshalled[i] is ReceivePort) {
           throw new Exception("Despite the documentation, you cannot send a ReceivePort");
         } 
       }
       return process(marshalled);
     }).flatten();
   }
 
   Promise<SendPort> _promise;
   static Map<SendPort, Dispatcher> _dispatchers;
 
 }