anchor.diff:    Value visitIntLiteral(IntLiteral node, env) => new IntValue(node.value);
     Value visitDoubleLiteral(DoubleLiteral node, env) =>
         new DoubleValue(node.value);
  -  Value visitBoolLiteral(BoolLiteral node, env) => new BoolValue(node.value);
  -  Value visitNullLiteral(NullLiteral node, env) => new NullValue();
  +  Value visitBoolLiteral(BoolLiteral node, env) =>
  +      node.value ? Value.trueInstance : Value.falseInstance;
  +  Value visitNullLiteral(NullLiteral node, env) => Value.nullInstance;
   
     Value visitLet(Let node, env) {
       var value = eval(node.variable.initializer, env);
  
positive.code: // Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
  // for details. All rights reserved. Use of this source code is governed by a
  // BSD-style license that can be found in the LICENSE file.
  library kernerl.interpreter;
  
  import '../ast.dart';
  
  
negative.code:       // Special evaluation of print.
        var res = eval(node.arguments.positional[0], env);
        print(res.value);
        return Value.nullInstance;
      } else {
        throw new NotImplemented('Support for statement type '
            '${node.runtimeType} is not implemented');
      }
    }
  
    Value visitMethodInvocation(MethodInvocation node, env) {
      // Currently supports only method invocation with <2 arguments and is used
      // to evaluate implemented operators for int, double and String values.
      var receiver = eval(node.receiver, env);
      if (node.arguments.positional.isNotEmpty) {
        var argValue = eval(node.arguments.positional.first, env);
        return receiver.invokeMethod(node.name.name, argValue);
      } else {
        return receiver.invokeMethod(node.name.name);
      }
    }
  
    Value visitConstructorInvocation(ConstructorInvocation node, env) =>
        defaultExpression(node, env);
  
    Value visitNot(Not node, env) {
      Value operand = eval(node.operand, env).toBoolean();
      return identical(operand, Value.trueInstance)
          ? Value.falseInstance
          : Value.trueInstance;
    }
  
    Value visitLogicalExpression(LogicalExpression node, env) {
      if ('||' == node.operator) {
        BoolValue left = eval(node.left, env).toBoolean();
        return identical(left, Value.trueInstance)
            ? Value.trueInstance
            : eval(node.right, env).toBoolean();
      } else {
        assert('&&' == node.operator);
        BoolValue left = eval(node.left, env).toBoolean();
        return identical(left, Value.falseInstance)
            ? Value.falseInstance
            : eval(node.right, env).toBoolean();
      }
    }
  
    Value visitConditionalExpression(ConditionalExpression node, env) {
      var condition = eval(node.condition, env).toBoolean();
      return identical(condition, Value.trueInstance)
          ? eval(node.then, env)
          : eval(node.otherwise, env);
    }
  
    Value visitStringConcatenation(StringConcatenation node, env) {
  