Returns true if the passed value is iterable, false otherwise
@param {Object} value The value to test
@return {Boolean}
18740
function (value) {
                var type = typeof value,
                    checkLength = false;
                if (value && type != 'string') {
                    // Functions have a length property, so we need to filter them out
                    if (type == 'function') {
                        // In Safari, NodeList/HTMLCollection both return "function" when using typeof, so we need
                        // to explicitly check them here.
//                        if (Ext.isSafari) {
//                            checkLength = value instanceof NodeList || value instanceof HTMLCollection;
//                        }
                    } else {
                        checkLength = true;
                    }
                }
                return checkLength ? value.length !== undefined : false;
            }
1286276
public static function isCountable($value): bool
    {
        if (is_array($value)) {
            return true;
        }

        if (is_object($value) && ($value instanceof Countable)) {
            return true;
        }

        return false;
    }
261580
function each (iterable, fn) {
        var len
            , i = 0
            , iter
            , item
            , ret
        ;

        if (!iterable) throw genTypeError($invalidArgument);

        var gen = iterable[Symbol[$iterator]];
        if (isFunction(gen))
            iter = gen.call(iterable);
        else if (isFunction(iterable.next)) {
            iter = iterable;
        }
        else if (isInstanceOf(iterable, Arr)) {
            len = iterable.length;
            while (i < len) {
                fn(iterable[i], i++);
            }
            return i;
        } else
            throw genTypeError($invalidArgument);

        while (!(item = iter.next()).done) {
            ret = genTryCatcher(fn)(item.value, i++);
            if (ret === $tryErr) {
                isFunction(iter[$return]) && iter[$return]();
                throw ret.e;
            }
        }

        return i;
    }
1077737
public boolean isApplicable( VarValueDef value)
    {
    return
      value.isNA()
      ? isOptional()
      : getValue( value.getName()) != null;
    }
1065562
function isLogicalArray( value ) {
	var len, val;
	if ( !isArray( value ) ) {
		return false;
	}
	len = value.length;
	if ( !len ) {
		return false;
	}
	for ( var i = 0; i < len; i++ ) {
		val = value[ i ];
		if ( !isNumber( val ) || (val !== 0 && val !== 1) ) {
			return false;
		}
	}
	return true;
}
82146
function isDateArray( value ) {
	var len;
	if ( !isArray( value ) ) {
		return false;
	}
	len = value.length;
	if ( !len ) {
		return false;
	}
	for ( var i = 0; i < len; i++ ) {
		if ( !isDate( value[i] ) ) {
			return false;
		}
	}
	return true;
}
79984
def is_iterable_but_not_string(obj):
    
    return hasattr(obj, '__iter__') and not isinstance(obj, str) and not isinstance(obj, bytes)
477591
def __iterate_value(self, value):
        
        if hasattr(value, '__dict__') or isinstance(value, dict):
            return self.__find_object_children(value)  # go through dict/class
        elif isinstance(value, (list, tuple, set)):
            return self.__construct_list(value)  # go through list
        return self.safe_values(value)
1015189
def is_iter_non_string(obj):
    """"""
    if isinstance(obj, list) or isinstance(obj, tuple):
        return True
    return False
936473
function isNumberArray( value ) {
	var len;
	if ( !isArray( value ) ) {
		return false;
	}
	len = value.length;
	if ( !len ) {
		return false;
	}
	for ( var i = 0; i < len; i++ ) {
		if ( !isNumber( value[i] ) ) {
			return false;
		}
	}
	return true;
}
1244636
public boolean isArray(Object value) {

        return value != null && (value.getClass().isArray() || value instanceof List);
    }
693884
public boolean containsValue(final Object value) {
	return ! forEachPair( 
		new IntObjectProcedure() {
			public boolean apply(int iterKey, Object iterValue) {
				return (value != iterValue);
			}
		}
	);
}
766965
public boolean containsValue(Object value) {
        for (LinkedHashMapEntry<K,V> e = head; e != null; e = e.after) {
            V v = e.value;
            if (v == value || (value != null && value.equals(v)))
                return true;
        }
        return false;
    }
467482
public static boolean contains(Iterable<?> iterable, Object value)
    {
        if (iterable instanceof Collection)
        {
            return ((Collection<?>) iterable).contains(value);
        }
        if (iterable instanceof RichIterable)
        {
            return ((RichIterable<?>) iterable).contains(value);
        }
        return IterableIterate.detectIndex(iterable, Predicates.equal(value)) > -1;
    }
756360
function contains(array, value) {
    var result = false;
    each(array, function (item) {
        result = item === value;
        return !result;
    });

    return result;
}
21202
def is_iterable(obj):
    
    if isinstance(obj, (str, bytes, bytearray)):
        return False
    return isinstance(obj, Iterable)
1047833
function isUsableImmutablePrimitive(x) {
    var typeOfX = (0, _typeOf.typeOf)(x);
    return isset(x) && [_String, _Number, _Boolean, _Symbol].some(function (Type) {
      return Type === typeOfX;
    });
  }