anchor.diff:        parser.set(_defined[name]);
       });
       set(Transformations.removeSetables(ref('start')));
  +    _undefined.clear();
  +    _completed = true;
     }
   
     /**
  -   * Initializes the composite grammar.
  +   * Returns a reference to a production with a [name].
  +   *
  +   * This method works during initialization and after completion of the
  +   * initialization. During the initialization it returns delegate parsers
  +   * that are eventually replaced by the real parsers. Afterwards it
  +   * returns the defined parser (mostly useful for testing).
      */
  -  void initialize();
  +  Parser ref(String name) {
  +    if (_completed) {
  +      if (_defined.containsKey(name)) {
  +        return _defined[name];
  +      } else {
  +        throw new StateError('Undefined production: $name');
  +      }
  +    } else {
  +      return _undefined.putIfAbsent(name, () {
  +        return failure('Uninitalized production: $name').setable();
  +      });
  +    }
  +  }
  +
  +  /**
  +   * Convenience operator returning a reference to a production with
  +   * a [name]. See [CompositeParser#ref] for details.
  +   */
  +  Parser operator [](String name) => ref(name);
   
     /**
      * Defines a production with a [name] and a [parser]. Only call this method
  
positive.code:  */
  abstract class CompositeParser extends _SetableParser {
  
    final Map<String, Parser> _defined;
    final Map<String, SetableParser> _undefined;
  
    CompositeParser()
        : super(failure('Uninitalized production: start')),
          _defined = new Map(),
          _undefined = new Map() {
      initialize();
      _delegate = ref('start');
      _undefined.forEach((name, parser) {
        if (!_defined.containsKey(name)) {
  
negative.code:    *     def('list', ref('element').separatedBy(char(',')));
     */
    void def(String name, Parser parser) {
      if (_completed) {
        throw new StateError('Completed parsers cannot be changed');
      } else if (_defined.containsKey(name)) {
        throw new StateError('Duplicate production: $name');
      } else {
        _defined[name] = parser;
      }
    }
  
    /**
  