anchor.diff:    }
   }
   
  -class StringConcatenationContinuation extends ExpressionContinuation {
  -  final List<Expression> expressions;
  -  final Environment environment;
  -  final ExpressionContinuation continuation;
  -
  -  int _currentPosition = 0;
  -  final List<Value> _values = <Value>[];
  -
  -  StringConcatenationContinuation(
  -      this.expressions, this.environment, this.continuation);
  -
  -  Configuration call(Value value) {
  -    _values.add(value);
  -    if (_values.length == expressions.length) {
  -      StringBuffer res = new StringBuffer();
  -
  -      for (int i = 0; i < expressions.length; i++) {
  -        res.write(_values[i].value);
  -      }
  -
  -      Value value = new StringValue(res.toString());
  -      return new ContinuationConfiguration(continuation, value);
  -    }
  -    return new ExpressionConfiguration(
  -        expressions[++_currentPosition], environment, this);
  +class StringConcatenationContinuation extends ApplicationContinuation {
  +  final ExpressionContinuation continuation;
  +
  +  StringConcatenationContinuation(this.continuation);
  +
  +  Configuration call(List<InterpreterValue> values) {
  +    StringBuffer result = new StringBuffer();
  +    for (InterpreterValue v in values.reversed) {
  +      result.write(v.value.value);
  +    }
  +    return new ContinuationConfiguration(
  +        continuation, new StringValue(result.toString()));
     }
   }
   
  
positive.code:   InterpreterValue assignValue(Value v);
  }
  
  class PositionalArgumentExpression extends InterpreterExpression {
    final Expression expression;
  
    PositionalArgumentExpression(this.expression);
  
    InterpreterValue assignValue(Value v) => new PositionalArgumentValue(v);
  }
  
  class NamedArgumentExpression extends InterpreterExpression {
    final String name;
    final Expression expression;
  
    NamedArgumentExpression(this.name, this.expression);
    InterpreterValue assignValue(Value v) => new NamedArgumentValue(name, v);
  }
  
  class LocalInitializerExpression extends InterpreterExpression {
  
negative.code:     }
  
      Map<String, Value> named = new Map.fromIterable(
          args.where((InterpreterValue av) => av is NamedValue),
          key: (NamedValue av) => av.name,
          value: (NamedValue av) => av.value);
  
      // Add named parameters.
      for (VariableDeclaration v in function.namedParameters) {
  