function _indexOf(list, a, idx) {
    var inf, item;
    // Array.prototype.indexOf doesn't exist below IE9
    if (typeof list.indexOf === 'function') {
      switch (_typeof(a)) {
        case 'number':
          if (a === 0) {
            // manually crawl the list to distinguish between +0 and -0
            inf = 1 / a;
            while (idx < list.length) {
              item = list[idx];
              if (item === 0 && 1 / item === inf) {
                return idx;
              }
              idx += 1;
            }
            return -1;
          } else if (a !== a) {
            // NaN
            while (idx < list.length) {
              item = list[idx];
              if (typeof item === 'number' && item !== item) {
                return idx;
              }
              idx += 1;
            }
            return -1;
          }
          // non-zero numbers can utilise Set
          return list.indexOf(a, idx);

        // all these types can utilise Set
        case 'string':
        case 'boolean':
        case 'function':
        case 'undefined':
          return list.indexOf(a, idx);
        case 'object':
          if (a === null) {
            // null can utilise Set
            return list.indexOf(a, idx);
          }
      }
    }
    // anything else not covered above, defer to R.equals
    while (idx < list.length) {
      if (equals(list[idx], a)) {
        return idx;
      }
      idx += 1;
    }
    return -1;
  }
Returns `true` if its arguments are equivalent, `false` otherwise. Handles
cyclical data structures.

Dispatches symmetrically to the `equals` methods of both arguments, if
present.

@func
@memberOf R
@since v0.15.0
@category Relation
@sig a -> b -> Boolean
@param {*} a
@param {*} b
@return {Boolean}
@example

     R.equals(1, 1); //=> true
     R.equals(1, '1'); //=> false
     R.equals([1, 2, 3], [1, 2, 3]); //=> true

     const a = {}; a.v = a;
     const b = {}; b.v = b;
     R.equals(a, b); //=> true