anchor.diff:  
   // it
   class LazyStream {
  -  late StreamNext<List<int>> _stream;
  +  late StreamNext _stream;
     late List<int> _remainder;
     late List<int> _return;
     late Iterator<int> _iter;
  -  LazyStream.fromstream(Stream<List<int>> stream) {
  -    _stream = StreamNext<List<int>>.fromstream(stream);
  +  LazyStream.fromstream(Socket socket) {
  +    _stream = StreamNext.fromstream(socket);
       _return = <int>[];
       _remainder = <int>[];
       _iter = _remainder.iterator;
  
positive.code: 
    void onError(error) {
      done = true;
      if (_nfut >= 1) {
        _nfut = 0;
        for (Completer<T> e in _queue) {
          e.completeError(error);
        }
      }
    }
  
    void onDone() {
      onError("stream is closed");
    }
  
    Future<T> next() {
      if (_npack == 0) {
        if (done) {
          return Future<T>.error("stream closed");
        }
        _nfut += 1;
        _queue.addLast(Completer<T>());
        return _queue.last.future;
      } else {
        Completer<T> c = _queue.removeFirst();
        _npack -= 1;
        return c.future;
      }
  
negative.code: part of redis;
  
  // like Stream but has method next for simple reading
  class StreamNext {
    late Queue<Completer<List<int>>> _queue;
    late int _nfut;
    late int _npack;
    late bool done;
    late Socket socket;
    late StreamSubscription<List<int>> _sub;
    StreamNext.fromstream(Socket _socket) {
      _queue = Queue<Completer<List<int>>>();
      _nfut = 0;
      _npack = 0;
      done = false;
      socket = _socket;
      socket.listen(onData, onError: this.onError, onDone: this.onDone);
    }
  
    void onData(List<int> event) {
      if (_nfut >= 1) {
        Completer c = _queue.removeFirst();
        c.complete(event);
        _nfut -= 1;
      } else {
        Completer<List<int>> c = Completer<List<int>>();
        c.complete(event);
        _queue.addLast(c);
        _npack += 1;
  