anchor.diff:  
     Stream<T> _generate(Function generator, Function runner) async* {
       final args = _makeArgs(generator);
  -    final isolate = await Isolate.spawn<_IsolateArgs>(runner, args,
  +    if (_killedWith != null) {
  +      return;
  +    }
  +    _isolate = await Isolate.spawn<_IsolateArgs>(runner, args,
           onExit: isolateExit.sendPort,
           debugName: '${this.runtimeType}',
           errorsAreFatal: true);
  +    if (_killedWith != null) {
  +      _isolate.kill(priority: _killedWith);
  +      return;
  +    }
       // Get the port that _runIsolate sends to us for flow control
       final SendPort ackPort = await ackPortGetter.first;
       ackPortGetter.close();
  
positive.code:   final isolateExit = ReceivePort();
    final isolateResults = ReceivePort();
    final ackPortGetter = ReceivePort();
  
    _IsolateStreamGenerator(A _generatorArg, int Function(T) _sizeOf, int maxBuf)
        : this._raw(_generatorArg, _sizeOf,
  
negative.code:       A generatorArg,
        int Function(T value) sizeOf,
        {int maxBuf})
        : this._fromSink(
              _IsolateStreamGenerator<T, A>(generatorArg, sizeOf, maxBuf),
              generator);
  
    IsolateStream._fromSink(this._isolateManager,
        Future<void> Function(A, IsolateGeneratorSink<dynamic>) generator)
        : super(_isolateManager.generateFromSink(generator));
  
    /// Request our generating to shut down, by calling Isolate.kill with the
    /// given argument.  This should not normally be necessary, but it may be
    /// useful to clean up under exceptional circumstances.
    void kill({int priority: Isolate.beforeNextEvent}) =>
        _isolateManager.kill(priority);
  }
  
  /// A helper to do the work of generating a Stream<T> in another isolate.
  