a generic type at all here, just to be sure
500214
@Override
    public List values(CacheKeyFilter filter) throws IOException {
	if (CacheUtil.allowAll(filter)) return values();

	List<String> keys = keys();

	List<Object> list = new ArrayList<Object>();
	Iterator<String> it = keys.iterator();
	String key;
	while (it.hasNext()) {
	    key = it.next();
	    if (filter.accept(key)) {
		CacheEntry ce = getQuiet(key, null);
		if (ce != null) // possible that the entry is gone since keys(); call above
		    list.add(ce.getValue());
	    }
	}
	return list;
    }
335982
def oftype(self, typ):
        ''''''
        for key, val in self.items():
            if val.type == typ:
                yield key
185754
function fromUnaryType(t) {
    return UnaryType (t.name)
                     (t.url)
                     (t.supertypes)
                     (t._test ([]))
                     (t._extractors.$1);
  }
184754
def is_union_type(tp):
    
    if NEW_TYPING:
        return (tp is Union or
                isinstance(tp, _GenericAlias) and tp.__origin__ is Union)
    return type(tp) is _Union
1072208
public static <T> SameType<T> of(TreeDef<T> treeDef, T expected, T actual) {
		return of(treeDef, expected, treeDef, actual).mapToSame(Function.identity(), Function.identity());
	}
419806
def is_type(value):
        """"""
        if isinstance(value, type):
            return issubclass(value, Type)
        return isinstance(value, Type)
744469
void addGenericTypes(String paramName, Map<String, Object> generics) {
        genericTypes.put(paramName, generics);
    }
90745
function genericUnit (server) {
  var processors = [];
  server.handler = function (f) { processors.push(f); };
  return function genericLayer (req, res, next) {
    for (var i = 0; i < processors.length; i++) {
      var keep = processors[i](req.ask);
      if (keep) { return; }  // Don't call next, nor the rest.
    }
    next();  // We never catch that request.
  };
}
84135
function isSameType(x, y) {
  const tX = type(x)
  const tY = type(y)

  return tX === tY
    || isFunction(x) && x.name === tY
    || isFunction(y) && y.name === tX
}
88145
def type(self, newtype):
        """"""
        self._type = newtype
        if self.is_multi:
            for sibling in self.multi_rep.siblings:
                sibling._type = newtype
1215698
def is_iterable(etype) -> bool:
    
    return type(etype) is GenericMeta and issubclass(etype.__extra__, Iterable)
754428
def is_regex_type(type_):
    

    return (
        callable(type_)
        and getattr(type_, "__name__", None) == REGEX_TYPE_NAME
        and hasattr(type_, "__supertype__")
        and is_compiled_pattern(type_.__supertype__)
    )
1232556
def match_type?(object)
            result = object.kind_of_any? self.type_classes
            if not result
                result = object.type_of_any? self.type_types
            end
            
            return result
        end
1133380
def generic_items
      return items if respond_to? :items
      len = Twostroke::Runtime::Types.to_number(get "length").number
      return [] if (len.is_a?(Float) && (len.nan? || len.infinite?)) || len < 0
      len = len.to_i
      (0...len).map { |i| get i.to_s }
    end
955734
def _valid_other_type(x, types):
    
    return all(any(isinstance(el, t) for t in types) for el in np.ravel(x))
1287284
public void popGenericType () {
		int size = genericTypesSize;
		if (size == 0) return;
		size--;
		if (depths[size] < kryo.getDepth()) return;
		genericTypes[size] = null;
		genericTypesSize = size;
	}
213246
function isType(type, input) {
	if (input === null) {
		return type.toLowerCase() === 'null';
	}

	return typeof input === type.toLowerCase() || Type.is(type, input);
}