anchor.diff:        this.result = result;
       } else {
         this.result = new Set();
  -      this.resutt.add(null);
  +      this.result.add(null);
       }
     }
   }
  
positive.code: 
    bool isNullable() => this.first.isNullable() && this.second.isNullable();
    bool isEmpty() => this.first.isNullable() || this.second.isNullable();
    Set parseNull(){
      Set result = new Set();
      for ( var l in this.first.parseNull()) {
        for (var r in this.second.parseNull())
  
negative.code: library parse;
  
  import 'dart:core';
  
  /** Utility function for sets equality */
  bool set_equals(Set left, Set right){
    if(left == null || right == null)
      return false;
   
    //simplest case
    if(left.length != right.length)
      return false;
  
    //clone one of the sets
    var test = new Set.from(left);
    for(var value in right){
      if(test.contains(value))
        test.remove(value);
      else
        return false;
    }
    return test.isEmpty;
  }
  
  abstract class Parser {
  
    And operator +(Parser right){
      return new And(this, right);
    }
    
    Or operator |(Parser right){
      return new Or(this, right);
    }
    
    And operator *(Parser right){
      if( right != null)
        throw 'right of * must be null';
      return null;
    }
  
    static final _cache = {};
    Set _set;
    bool isNullable();
    bool isEmpty();
    Parser _derive(token);
    Set  _parseNull();
    Set  parseNull(){
      if(this._set != null)
        return this._set;
  
      Set anotherSet = new Set();
      do {
        this._set = anotherSet;
        anotherSet = this._parseNull();
      } while(!set_equals(this._set, anotherSet));
    }
    
    Parser derive(token){
      if(_cache[token] == null)
        _cache[token] = new Lazy(this, token);
      return _cache[token];
    }
    
    Set parse(List tokens){
      var parser = this;
      for( var token in tokens){
        parser = parser.derive(token);
  