anchor.diff:  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();
  -  Set  parseNull();
  -  Parser derive(token);
  -  
  -  List parse(List tokens){
  +  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);
  
positive.code: 
    bool isNullable() => false;
    bool isEmpty() => false;
    Set parseNull() => new Set();
    Parser derive(token){
      print('Token derive $token');
      if (this.token == token){
        var s = new Set();
  
negative.code:   }
  }
  
  class KleeneStar extends Parser {
    Parser parser;
    KleeneStar(this.parser);
    Set _parseNull() => this.parser.parseNull();
    Parser _derive(token) => this.parser.derive();
  }
  