anchor.diff:          .catchError(_onSocketError);
   
     }
  -  
  +
     Future auth(String _password) {
       this.password = _password;
       return sendCommand(RedisCommand.AUTH, [ _password ]).receive();
  
positive.code:     commands.setAll(1, args.map((String line) => UTF8.encode(line)).toList(growable: false));
      return rawSend(commands);
    }
    
    Receiver sendCommandWithVariadicValues(List<int> command, List<String> args, List<String> values) {
      var commands = new List<List<int>>(args.length + values.length + 1);    
      commands[0] = command;
      commands.setAll(1, args.map((String line) => UTF8.encode(line)).toList(growable: false));
      commands.setAll(args.length + 1, values.map((String line) => UTF8.encode(line)).toList(growable: false));
  
negative.code: 
  }
  
  final int _CR = 13;
  final int _LF = 10;
  
  final int _STATUS = 43;
  final int _ERROR = 45;
  final int _INTEGER = 58;
  final int _BULK = 36;
  final int _MULTI_BULK = 42;
  
  abstract class _RedisConsumer {
    int consume(List<int> data, int start, int end);
    RedisReply makeReply();
    final List<List<int>> _dataBlocks = [];
    bool _done = false;
  }
  
  class _LineConsumer extends _RedisConsumer {
    int consume(List<int> data, int start, int end) {
      assert(start < end);
      bool haveSome = !_dataBlocks.isEmpty;
      var prev = haveSome? _dataBlocks.last.last : data[start];
      var i = haveSome? start : start + 1;
  
      for(; i < end; i++) {
        final next = data[i];
        if(prev == _CR && next == _LF) {
          _done = true;
          break;
        }
        prev = next;
      }
  
      assert(i > start && i <= end);
      _dataBlocks.add(new UnmodifiableListView(data.getRange(start, i)));
      return i;
    }
  
    List<int> get data {
      assert(_done);
  
      if(_data == null) {
        final dataSize = _dataBlocks.fold(0, (int prevValue, List dataBlock) =>
            prevValue + dataBlock.length);
        _data = new List<int>(dataSize - 2);
        var blocksNeeded = _dataBlocks.size;
        var ignoredCharacters = 2;
        if(_dataBlocks.last.length == 1) {
          assert(_dataBlocks.last.last == _LF);
          ignoredCharacters--;
          blocksNeeded--;
          assert(_dataBlocks[blocksNeeded-1].last = _CR);
        }
  
        var stringIndex = 0;
        for(var blockIndex=0; blockIndex < blocksNeeded; blockIndex++) {
          final currentBlock = _dataBlocks[0];
  
          _asString.setAll(stringIndex,
              blockIndex == blocksNeeded - 1?
              currentBlock.take(currentBlock.length - ignoredCharacters) :
              currentBlock);
        }
      }
      return _data;
    }
  
    String get line => {
      if(_line == null) {
        _line = UTF8.decode(data);
      }
      return _line;
    }
  
    /// The joined _dataBlocks
    List<int> _data;
    /// The line data as String
    String _line;
  }
  
  class _BlockConsumer extends _RedisConsumer {
    int consume(List<int> data, int start, int end) {
      int result;
      assert(start < end);
      if(_lengthRequired == null) {
        final newEnd = _lineConsumer.consume(data, start, end);
        assert(newEnd > start && newEnd <= end);
        if(_lineConsumer.done) {
          _lengthRequired = int.parse(new String.fromCharCode(_lineConsumer.data));
          result = newEnd < end? consume(data, newEnd, end) : newEnd;
        } else {
          result = newEnd;
        }
      } else {
        final needed = _lengthRequired - _length;
        final desiredEnd = start + needed;
        final takeTo = min(desiredEnd, end);
        _dataBlocks.add(new UnmodifiableListView(data.getRange(start, takeTo)));
        _addToLength(takeTo - start);
        result = takeTo;
      }
      assert(result > start && result <= end);
      return result;
    }
  
    _addToLength(int additional) {
      _length += additional;
      assert(_length <= _lengthRequired);
      if(_length == _lengthRequired) _done = true;
    }
  
    LineConsumer _lineConsumer = new LineConsumer();
    int _length = 0;
    int _lengthRequired;
  }
  
  
  class _StatusConsumer extends _LineConsumer {
    RedisReply makeReply() => new StatusReply(line);
  }
  
  class _ErrorConsumer extends _LineConsumer {
    RedisReply makeReply() => new ErrorReply(line);
  }
  
  class _IntegerConsumer extends _LineConsumer {
    RedisReply makeReply() => new IntegerReply(int.parse(line));
  }
  
  class _BulkConsumer extends _BlockConsumer {
    RedisReply makeReply() => new BulkReply(data);
  }
  
  class _MultiBulkConsumer extends _RedisConsumer {
  
    int consume(List<int> data, final int start, final int end) {
      int current = start;
      assert(current < end);
      if(_numReplies == null) {
        current = _lineConsumer.consume(data, current, end);
        assert(newEnd <= end);
  
        if(_lineConsumer.done) {
          _numReplies = int.parse(new String.fromCharCode(_lineConsumer.data));
          result = current < end? consume(data, current, end) : end;
        }
      } else {
        if(_activeConsumer == null) {
          _activeConsumer = _makeRedisConsumer(current++);
        }
        if(current < end) {
          current = _activeConsumer.consume(data, current, end);
          if(_activeConsumer.done) {
  
          }
        }
      }
  
      assert(current > start && current <= end);
      return current;
    }
  
    RedisReply makeReply() => new MultiBulkReply();
    LineConsumer _lineConsumer = new LineConsumer();
    RedisConsumer _activeConsumer;
    int _numReplies;
    int _repliesReceived = 0;
  }
  
  class StatusReply extends RedisReply {
    ErrorReply(this.status);
    String toString() => "StatusReply: $status";
    final String status;
  }
  
  class ErrorReply extends RedisReply {
    ErrorReply(this.error);
    String toString() => "ErrorReply: $error";
    final String error;
  }
  
  class IntegerReply extends RedisReply {
    RedisReply(this.integer);
    String toString() => "IntegerReply: $integer";
    final int integer;
  }
  
  class BulkReply extends RedisReply {
    BulkReply(this.bytes);
  
    String get string {
      if(_dataAsString == null) {
        _dataAsString = UTF8.decode(bytes);
      }
      return _dataAsString;
    }
  
    String _dataAsString;
    final List<int> bytes;
  }
  
  class MultiBulkReply extends RedisReply {
    MutliBulkReply(this.replies);
    final List<RedisReply> replies;
  }
  
  RedisConsumer _makeRedisConsumer(final int replyType) {
    switch(replyType) {
      case _STATUS: return new StatusConsumer();
      case _ERROR: return new ErrorConsumer();
      case _INTEGER: return new LineConsumer();
      case _BULK: return new BulkConsumer();
      case _MULTI_BULK: return new MultiBulkConsumer();
      default: throw new InvalidRedisResponseError(
        "The type character was incorrect (${new String.fromCharCode(replyTypeChar)}).");
    }
  }