types : type
                 | type COMMA types
498597
def p_types(self, p):
        ''''''
        if len(p) == 2:
            p[0] = tuple((t,) for t in p[1])
        else:
            p[0] = tuple((t,) + ts for t in p[1] for ts in p[3])
277354
def types(self):
        
        return [x for x in self[self.current_scope].values() if isinstance(x, symbols.TYPE)]
1230199
def _type_to_str(self, type):
        
        for key, val in self.TYPE_NAMES.items():
            if key == type:
                return val
1067820
function Types() {
    this.binary = specs.ABinary;
    this.string = specs.AString;
    this.bool = specs.ABoolean;
    this.byte = specs.AByte;
    this.i16 = specs.AInt16;
    this.i32 = specs.AInt32;
    this.i64 = specs.AInt64;
    this.double = specs.ADouble;
}
1222300
def types(*args, **kwargs):
    

    rtype = first(args)

    return Types(rtype=rtype, ptypes=kwargs)
1276494
def is_string_type(type_):
    

    string_types = _get_types(Types.STRING)
    if is_typing_type(type_):
        return type_ in string_types or is_regex_type(type_)
    return type_ in string_types
335982
def oftype(self, typ):
        ''''''
        for key, val in self.items():
            if val.type == typ:
                yield key
506408
function(type) {
  var t = '[' + type.toUpperCase() + ']';
  
  return utils.filler(t, utils.longestKey(CONSTS, 2));
}
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__)
    )
109251
def types(self):
        """"""
        res = []
        for column in self.column_definitions:
            tmp = column.get('type', None)
            res.append(ModelCompiler.get_column_type(tmp)) if tmp else False
        res = list(set(res))
        return res
1163629
function(type){
            type = this.string(type);
            if(types.indexOf(type.toLowerCase()) < 0){
                throw new TypeError('a type in [' + types.join(', ') + '] is expected, but ' + type + ' given');
            }
            return type.toLowerCase();
        }
1261788
def get_types(self):
        
        types = [str, int, int]
        if self.strandPos is not None:
            types.append(str)
        if self.otherPos:
            for o in self.otherPos:
                types.append(o[2])

        return types
666168
def types(self):
        
        data = clips.data.DataObject(self._env)

        lib.EnvDeftemplateSlotTypes(
            self._env, self._tpl, self._name, data.byref)

        return tuple(data.value) if isinstance(data.value, list) else ()
359811
private String printConfigTypes(
      HashMap<?, MtasParserType<MtasParserMapping<?>>> types) {
    StringBuilder text = new StringBuilder();
    for (Entry<?, MtasParserType<MtasParserMapping<?>>> entry : types
        .entrySet()) {
      text.append("- " + entry.getKey() + ": " + entry.getValue().items.size()
          + " mapping(s)\n");
      for (int i = 0; i < entry.getValue().items.size(); i++) {
        text.append("\t" + entry.getValue().items.get(i) + "\n");
      }
    }
    return text.toString();
  }
638391
function fieldTypes (type) {
  switch (type) {
    case constants.ID:
    case constants.string:
      return 'string'

    case constants.int:
    case constants.float:
      return 'number'

    default:
  }
}
754247
function typeVarNames(t) {
    return Z.concat (
      t.type === VARIABLE ? [t.name] : [],
      Z.chain (function(k) { return typeVarNames (t.types[k]); }, t.keys)
    );
  }
1174963
def types(self):
        
        data = clips.data.DataObject(self._env)

        lib.EnvSlotTypes(self._env, self._cls, self._name, data.byref)

        return tuple(data.value) if isinstance(data.value, list) else ()