anchor.diff:   * possible values for [substitution].
    */
   substitute(var substitution, var arguments) {
  -  assert(isNull(substitution) ||
  +  assert(substitution == null ||
            isJsFunction(substitution));
  -  assert(isNull(arguments) || isJsArray(arguments));
  +  assert(arguments == null || isJsArray(arguments));
     if (isJsFunction(substitution)) {
       substitution = invoke(substitution, arguments);
       if (isJsArray(substitution)) {
  
positive.code: /**
   * Checks whether the types of [s] are all subtypes of the types of [t].
   *
   * [s] and [t] are either [:null:] or JavaScript arrays of type representations,
   * A [:null:] argument is interpreted as the arguments of a raw type, that is a
   * list of [:dynamic:]. If [s] and [t] are JavaScript arrays they must be of the
   * same length.
   *
   * See the comment in the beginning of this file for a description of type
   * representations.
   */
  bool areSubtypes(var s, var t) {
    // [:null:] means a raw type.
    if (isNull(s) || isNull(t)) return true;
  
    assert(isJsArray(s));
    assert(isJsArray(t));
  
negative.code: 
  hasNoField(var object, var name) => !hasField(object, name);
  
  /// Returns `true` if [o] is a JavaScript function.
  bool isJsFunction(var o) => JS('bool', r'typeof # == "function"', o);
  
  /// Returns `true` if [o] is a JavaScript object.
  bool isJsObject(var o) => JS('bool', r"typeof # == 'object'", o);
  
  /**
   * Returns `true` if the JavaScript values [s] and [t] are identical. We use
   * this helper instead of [identical] because `identical` needs to merge
   * `null` and `undefined` (which we can avoid).
   */
  bool isIdentical(var s, var t) => JS('bool', '# === #', s, t);
  
  /**
   * Returns `true` if the JavaScript values [s] and [t] are not identical. We use
   * this helper instead of [identical] because `identical` needs to merge
   * `null` and `undefined` (which we can avoid).
   */
  bool isNotIdentical(var s, var t) => JS('bool', '# !== #', s, t);
  