anchor.diff:  
       String get name => _name;
   
  -    SignalSubscription subscribe(SignalHandler<T> userHandler, {String 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.onData(wrappingHandler);
           streamSubscription.onError((err) => throw new StateError("error in $name signal/event stream: $err"));
   
           return mySignalSubscription;
  
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: 
      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();
  }
  