anchor.diff:    }
   
     /**
  +   * Returns a reference to a production with a [name]. Only call this method
  +   * from [initialize].
  +   *
  +   * At the point of calling [ref] the production does not necessaryily have
  +   * to be defined yet. The constructor of the class makes sure to replace
  +   * and optimize references away before the grammar is run.
  +   */
  +  Parser ref(String name) {
  +    return _undefined.putIfAbsent(name, () {
  +      return failure('Uninitalized production: $name').setable();
  +    });
  +  }
  +
  +  /**
      * Redefinies an existing production with a [name] and a [function]
  -   * producing a new parser.
  +   * producing a new parser. The code raises a [StateError] if [name]
  +   * is an undefined production. Only call this method from [initialize].
  +   *
  +   * The following example redefines the previously defined list production
  +   * by making it optional:
  +   *
  +   *     redef('list', (parser) => parser.optional());
      */
     void redef(String name, Parser function(Parser)) {
       if (!_defined.containsKey(name)) {
  
positive.code:  *
   * To create a new composite grammar subclass [CompositeParser]. Override
   * the method [initialize] and for every production call [def] giving the
   * parsers a name. The start production must be named 'start'. To refer to
   * other produtions use [ref]. To redefine or attach actions to productions
   * use [redef] and [action].
   */
  abstract class CompositeParser extends _SetableParser {
  
  
negative.code:   void initialize();
  
    /**
     * Defines a production with a [name] and a [parser]. Only call this method
     * from [initialize].
     *
     * The following example defines a list production that consumes
     * several elements separated by a comma.
     *
     *     def('list', ref('element').separatedBy(char(',')));
     */
    void def(String name, Parser parser) {
      if (_defined.containsKey(name)) {
  