anchor.diff:  /// This [Language] is used as the last derivative to test wheather it is a
   /// match.
   class EndOfInput extends Language {
  -  Language derive(dynamic ch) => empty;//(ch == EOI)? match: empty;
  +  Language derive(dynamic ch) => reject;//(ch == EOI)? match: reject;
     toString() => '<EOI>';
  -  Language derveEnd(dynamic ch) => match;
   }
   
   
  
positive.code:   final Language left;
    final Language right;
  
    bool get isMatch => left.isMatch && right.isMatch;
    bool get canAccept => left.canAccept && right.canAccept;
    bool get isReject => left.isReject || right.isReject;
  
    And._internal(this.left, this.right);
  
    factory And(left, right){
      if(left == match) return right;
      //if(right == match) return left; // Really? does this make sense?
      if(left == empty || right == empty) return empty;
      return new And._internal(left, right);
    }
  
    Language derive (String c) {
  
      // TODO(Sam): It looks like we need this only for Star.. Is this true?
      if(left.canAccept){
        return new Or(new And(left.derive(c), right), right.derive(c));
      }
      return new And(left.derive(c), right);
  
negative.code:   final Language left;
    final Language right;
  
    bool get isMatchable => left.isMatchable || right.isMatchable;
  
    Or._internal(this.left, this.right);
    factory Or(left, right){
      if (left == reject && right == reject) return reject;
      if (left == reject) return right;
      if (right == reject) return left;
      if (left == match || right == match) return match;
      return new Or._internal(left, right);
    }
  