anchor.diff:    if (f == null) {
       return null;
     }
  -  return new FSCompositeFunctionCall(t, f);
  +  return new _FSCompositeFunctionCall(t, f);
   });
   
  -FSTarget _parseFSTarget(String string) =>
  +_FSTarget _parseFSTarget(String string) =>
   _firstNotNull([_parseFSType, _parseFSFunctionCall])(string);
   
   /*
    * <type>                       = <name> | [a-zA-Z_][A-Za-z0-9_\]+[a-zA-Z_]
    */
  -FSType _parseFSType(String string) {
  +_FSType _parseFSType(String string) {
   
     var n = _parseFSName(string);
     if (n != null) {
  
positive.code: }
  
  
  class FSFunctionChainCompositeFunction extends FSCompositeFunction {
    final FSFunctionChain function;
  
    FSFunctionChainCompositeFunction(this.function);
  
    String toString() => "." + function.toString();
  
    List<FSFunctionCall> toFunctionCalls(FSTarget target) => [function.toFunctionCall(target)];
  
  }
  
  abstract class FSFunctionChain {
  
    FSFunctionCall toFunctionCall(FSTarget target);
  
  }
  
  class FSChainFunctionChain extends FSFunctionChain {
    final FSChainFunctionChain chain;
    final FSFunction function;
  
    FSChainFunctionChain(this.chain, this.function);
  
    String toString() => chain.toString() + function.toString();
  
    FSFunctionCall toFunctionCall(FSTarget target) => new FSFunctionCall(chain.toFunctionCall(target), function);
  
  }
  
  abstract class FSFunction extends FSFunctionChain {
  
    FSFunctionCall toFunctionCall(FSTarget target) => new FSFunctionCall(target, this);
  
  }
  
  abstract class FSNamedFunction extends FSFunction {
  
    final FSName name;
  
    FSNamedFunction(this.name);
  
    String toString() => "." + name.toString();
  
    List<FSArgument> get argumentList;
  
    List<FSArgument> get positionalArgumentList;
  
    Map<String, FSArgument> get namedArgumentMap;
  
    List<dynamic> computedPositionalArgumentList(dynamic converter(FSProgram));
  
    Map<String, dynamic> computedNamedArgumentMap(dynamic converter(FSProgram));
  
  }
  
  class FSNoArgumentFunction extends FSNamedFunction {
  
    FSNoArgumentFunction(FSName name) : super(name);
  
    String toString() => super.toString() + "()";
  
    List<FSArgument> get argumentList => [];
  
    List<FSArgument> get positionalArgumentList => [];
  
    Map<String, FSArgument> get namedArgumentMap => {
    };
  
    List<dynamic> computedPositionalArgumentList(dynamic converter(FSProgram)) => positionalArgumentList;
  
    Map<String, dynamic> computedNamedArgumentMap(dynamic converter(FSProgram)) => namedArgumentMap;
  }
  
  class FSArgumentFunction extends FSNamedFunction {
  
    final FSArgument argument;
  
    FSArgumentFunction(FSName name, this.argument) : super(name);
  
    String toString() => super.toString() + "(" + argument.toString() + ")";
  
    List<FSArgument> get argumentList => argument.toArgumentList();
  
    List<FSArgument> get positionalArgumentList {
      var l = argumentList;
      l.removeWhere((FSArgument a) => a is FSNamedArgument);
      l.map((FSArgument a) => a.value);
      return l;
    }
  
    Map<String, FSArgument> get namedArgumentMap {
      var l = argumentList;
      l.removeWhere((FSArgument a) => a is! FSNamedArgument);
      var m = new Map.fromIterable(l, key:(FSNamedArgument a) => a.name.value, value:(FSNamedArgument a) => a.value);
  
      return m;
  
    }
  
  
    List<dynamic> computedPositionalArgumentList(dynamic converter(FSProgram)) => positionalArgumentList.map((FSArgument a) => a.value.compute(converter)).toList();
  
    Map<String, dynamic> computedNamedArgumentMap(dynamic converter(FSProgram)) {
      var m = namedArgumentMap;
      return new Map.fromIterables(m.keys, m.values.map((FSArgument a) => a.value.compute(converter)));
    }
  }
  
  
  class FSArrayAccessFunction extends FSFunction {
  
    final FSScalar scalar;
  
  
    FSArrayAccessFunction(this.scalar);
  
    String toString() => "[" + scalar.toString() + "]";
  
  }
  
  class FSArgument {
  
    final FSScalarArrayProgram value;
  
    FSArgument(this.value);
  
    String toString() => value.toString();
  
    List<FSArgument> toArgumentList() => [this];
  
  }
  
  class FSArguments extends FSArgument {
  
    final FSArgument argument;
  
    FSArguments(FSScalarArrayProgram value, this.argument) : super(value);
  
    String toString() => super.toString() + ", " + argument.toString();
  
    List<FSArgument> toArgumentList() {
      var l = argument.toArgumentList();
      l.insert(0, new FSArgument(this.value));
      return l;
    }
  
  }
  
  class FSNamedArgument extends FSArgument {
    final FSNotStartingWithUnderscoreName name;
  
    FSNamedArgument(this.name, FSScalarArrayProgram value) : super(value);
  
    String toString() => name.toString() + " : " + value.toString();
  
    List<FSArgument> toArgumentList() => [this];
  
  }
  
  class FSNamedArguments extends FSNamedArgument implements FSArguments {
    final FSNamedArgument argument;
  
    FSNamedArguments(FSNotStartingWithUnderscoreName name, FSScalarArrayProgram value, this.argument) : super(name, value);
  
    String toString() => super.toString() + ", " + argument.toString();
  
    List<FSArgument> toArgumentList() {
      var l = argument.toArgumentList();
      l.insert(0, new FSNamedArgument(this.name, this.value));
      return l;
    }
  }
  
  
  class FSName extends FSType {
  
    final String value;
  
    FSName(this.value);
  
    String toString() => "n{$value}";
  }
  
  class FSNotStartingWithUnderscoreName {
    final String value;
  
    FSNotStartingWithUnderscoreName(this.value) ;
  
    String toString() => "nwou{$value}";
  }
  
  
  abstract class FSScalarArrayProgram {
  
    dynamic compute(dynamic computer(FSProgram));
  
  }
  
  class FSArray extends FSScalarArrayProgram {
    final FSArrayEntry entry;
  
    List<FSArrayEntry> get entries => entry.toEntryList();
  
    bool get isList => entries.every((FSArrayEntry e) => e is! FSNamedArrayEntry);
  
    bool get isMap => !isList;
  
    Map computeMap(dynamic computer(FSProgram)) {
  
      var resultMap = {
      };
  
      var i = 0;
  
      entries.forEach((FSArrayEntry entry) {
        if (entry is FSNamedArrayEntry) {
          FSNamedArrayEntry e = entry;
          if (e.key is FSIntNumScalar) {
            i = Math.max(i, e.key.value);
          }
          resultMap[e.key.value] = e.value.compute(computer);
        } else {
          FSArrayEntry e = entry;
          resultMap[i] = e.value.compute(computer);
          i++;
        }
  
negative.code:   }
    s = s.replaceAllMapped(new RegExp(r"([^\\])\\\\" + divider), (Match m) => "${m[1]}$divider");
    s = s.replaceAll(r"\\", r"\");
    return new _FSStringScalar(s.substring(1, s.length - 1));
  }
  
  /*
   * <function>                   = .<name>(<arg_list>) | .<name> () | \[<scalar>\]
   */
  _FSFunction _parseFSFunction(String s) {
  
    var scalar;
    if (s.startsWith("[") && s.endsWith("]") && (scalar = _parseFSScalar(s.substring(1, s.length - 1).trim())) != null) {
      return new _FSArrayAccessFunction(scalar);
    }
  
  
  