anchor.diff:        A generatorArg,
         int Function(T value) sizeOf,
         {int maxBuf})
  -      : super(_IsolateStreamGenerator<T, A>(generatorArg, sizeOf, maxBuf)
  -            .generateFromSink(generator));
  +      : 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.
  
positive.code:   /// for sizeOf and maxBuf, so long as you are consistent.
    IsolateStream(Iterator<T> Function(A) generator, A generatorArg,
        int Function(T value) sizeOf, {int maxBuf})
        : super(_IsolateStreamGenerator<T, A>(generatorArg, sizeOf, maxBuf)
              .generateFromIterator(generator));
  
    /// Create a new stream with the given generating function, which
    /// takes an argument of type A, and produces a StreamIterator<T>.
  
negative.code:         yield tv;
        }
      }
      _isolate.kill();
      final done = await isolateExit.first;
      await isolateExit.close();
    }
  
    /// See the documentation for IsolateStream.kill(int).
    void kill(int priority) {
      if (priority == null) {
        priority = Isolate.beforeNextEvent;
      }
      _killedWith = priority;
      // Record the priority in case _isolate is null -- see _generate().
      if (_isolate != null) {
        _isolate.kill(priority: priority);
      }
    }
  
    /// Initialize our run inside the isolate.
  