anchor.diff:          var inner = lambda_env.create();
           var names = lambda_args.head;
           var values = evalArgs(env, args);
  -        while (names is Cons && values is Cons) {
  +        while (names != null && values != null) {
             inner[names.head] = values.head;
             names = names.tail;
             values = values.tail;
           }
           var result = null;
           var stmt = lambda_args.tail;
  -        while (stmt is Cons) {
  +        while (stmt != null) {
             result = eval(inner, stmt.head);
             stmt = stmt.tail;
           }
  
positive.code:       }
        return result;
      };
      _natives['and'] = (Environment env, Dynamic args) {
        while (args != null) {
          if (!eval(env, args.head)) {
  
negative.code: // Copyright (c) 2012, Lukas Renggli <renggli@gmail.com>
  
  /** Collection of native functions. */
  class Natives {
  
    static Map<String, Dynamic> _natives;
  
    /** Looks a native function up. */
    static Dynamic find(String name) {
      _initialize();
      return _natives[name];
    }
    
    /** Imports all the native functions into the [environment]. */
    static void importAllInto(Environment env) {
      _initialize();
      _natives.forEach((key, value) {
        env[new Symbol(key)] = value;
      });
    }
  
    static void _initialize() {
      if (_natives == null) {
        _natives = new Map();
        _basicFunctions();
        _controlStructures();
        _arithmeticMethods();
        _arithmeticComparators();
        _listOperators();
      }
    }
  
    static void _basicFunctions() {
  