anchor.diff:  
       Future close() => _controller.close();
   }
  +
  +
  +void signalTest() {
  +    void test1() {
  +        Completer<int> c1 = new Completer<int>();
  +        SignalFunctions<int> MyEvent = new SignalFunctions<int>();
  +        MyEvent.subscribe((ev) => c1.complete(ev));
  +        MyEvent.fire(17);
  +        c1.future.then((i) {
  +            assert(i == 17);
  +            log("pass");
  +        });
  +    }
  +
  +    void test2() {
  +        Completer<int> c2a = new Completer<int>();
  +        Completer<int> c2b = new Completer<int>();
  +        Completer<int> c2c = new Completer<int>();
  +        Completer<int> c2d = new Completer<int>();
  +        SignalFunctions<int> MyEvent2 = new SignalFunctions<int>();
  +        MyEvent2.subscribe((ev) {
  +            if (ev == 1) c2a.complete(ev);
  +            if (ev == 2) c2b.complete(ev);
  +        });
  +        MyEvent2.subscribe((ev) {
  +            if (ev == 1) c2c.complete(ev);
  +            if (ev == 2) c2d.complete(ev);
  +        });
  +        MyEvent2.fire(1);
  +        MyEvent2.fire(2);
  +        Future.wait([c2a.future, c2b.future, c2c.future, c2d.future]).then((cs) {
  +            log("pass");
  +        });
  +    }
  +
  +    void test3() {
  +        Completer<int> c = new Completer<int>();
  +        SignalFunctions<int> MyEvent3 = new SignalFunctions<int>();
  +        MyEvent3.subscribe((ev) {
  +            assert(ev == 3);
  +            assert(ev != 5);
  +            if (ev == 3) c.complete(3);
  +        }, once: true);
  +        MyEvent3.fire(3);
  +        MyEvent3.fire(5);
  +        c.future.then((cs) {
  +            assert(cs == 3);
  +            log("pass");
  +        });
  +
  +        // TODO: we can't check that ev==5 is never called, since we have nothing to wait on for it...
  +    }
  +
  +    // test1();
  +    // test2();
  +    test3();
  +}
  
positive.code: 
  class SignalFunctions<T> {
      Signal<T> signal = new Signal<T>();
      SignalSubscription subscribe(SignalHandler<T> handler) {
          return signal.subscribe(handler);
      }
      void unsubscribe(SignalSubscription s) => signal.unsubscribe(s);
      void fire(T data) => signal.fire(data);
  
negative.code: 
      String get name => _name;
  
      SignalSubscription subscribe(SignalHandler<T> userHandler, {String name, bool once: false}) {
          var streamSubscription = _controller.stream.listen(null);
          var mySignalSubscription = new SignalSubscription(streamSubscription, name: name);
  
          var wrappingHandler = (_SignalData<T> data) {
              userHandler(data.data);
              if (once) {
                  mySignalSubscription.streamSubscription.cancel();
              }
          };
          streamSubscription.onData(wrappingHandler);
  
          streamSubscription.onError((err) => throw new StateError("error in $name signal/event stream: $err"));
  
          return mySignalSubscription;
  