anchor.diff:    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;
  +  bool get isMatchable => left.isMatchable || right.isMatchable;
   
     Or._internal(this.left, this.right);
     factory Or(left, right){
  -    if (left == empty && right == empty) return empty;
  -    if (left == empty) return right;
  -    if (right == empty) return left;
  +    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);
     }
  
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: class Star extends Language {
    final Language language;
  
    bool get isMatchable => true;
  
    Star._internal(this.language);
    factory Star(language){
      if(language == match) return match;
      if(language == reject) return reject;
      return new Star._internal(language);
    }
    Language derive(ch) => new And(language.derive(ch), new Star(language));
  