idtype in Uniq constants
348334
def getid(self, idtype):
        '''
        
        '''
        memorable_id = None
        while memorable_id in self._ids:
            l=[]
            for _ in range(4):
                l.append(str(randint(0, 19)))
            memorable_id = ''.join(l)
        self._ids.append(memorable_id)
        return idtype + '-' + memorable_id
535064
private ST genAlternativeTypes(ElementDefinition ed, String id, String shortId) {
    ST shex_alt = tmplt(ALTERNATIVE_SHAPES_TEMPLATE);
    List<String> altEntries = new ArrayList<String>();


    for(ElementDefinition.TypeRefComponent typ : ed.getType())  {
      altEntries.add(genAltEntry(id, typ));
    }
    shex_alt.add("altEntries", StringUtils.join(altEntries, " OR\n    "));
    return shex_alt;
  }
321059
function uniq(srcArr, pathStr, isDeep) {
      if (isUdf(isDeep)) isDeep = true;
      if (isBol(pathStr)) isDeep = pathStr, pathStr = UDF;
      pathStr = typeVal(pathStr, 'str');
      var tmpArr = srcArr.slice(), i = -1;
      while (++i < tmpArr.length - 1) {
        for (var j = i + 1; j < tmpArr.length; j++) {
          var isDuplicate;
          if (pathStr) {
            var val1 = get(tmpArr[i], pathStr), val2 = get(tmpArr[j], pathStr);
            isDuplicate = isDeep ? isDeepEqual(val1, val2) : val1 === val2;
          } else {
            isDuplicate = isDeep ? isDeepEqual(tmpArr[i], tmpArr[j]) : tmpArr[i] === tmpArr[j];
          }
          if (isDuplicate) tmpArr.splice(j--, 1);
        }
      }
      return tmpArr;
    }
685726
def uniqueId(self, prefix=""):
        
        _IdCounter.count += 1
        id = _IdCounter.count
        if prefix:
            return self._wrap(prefix + str(id))
        else:
            return self._wrap(id)
1310541
function IDPTYPE() {
		let make = ()=>(Math.random().toString(36).slice(2)), rslt = make();
		while (global.__PTYPES__.has(rslt)) { rslt = make(); }
		return rslt;
	}
685566
def subtype_ids(elements, subtype):
    
    return [i for (i, element) in enumerate(elements)
            if isinstance(element, subtype)]
260065
private int idToInt(String value) {
    try {
      return Integer.valueOf(value);
    } catch (NumberFormatException e) {
      throw new ConfigurationException("invalid type ID: " + value);
    }
  }
910902
def uniqid(iface='wlan0', is_hex=True):
    
    # return str(appid.getnode()) if not is_hex else str(hex(appid.getnode()))[2:-1]
    m_ = get_addr(iface)
    m_ = ''.join(m_.split(':')) if m_ else m_
    if m_ and not is_hex:
        m_ = str(int(m_.upper(), 16))
    return m_
573683
function uniq (gamut) {
  var semitones = heights(gamut)
  return gamut.reduce(function (uniq, current, currentIndex) {
    if (current) {
      var index = semitones.indexOf(semitones[currentIndex])
      if (index === currentIndex) uniq.push(current)
    }
    return uniq
  }, [])
}
144330
def p_type_def_4(t):
    """"""
    id = t[2]
    body = t[3]
    lineno = t.lineno(1)
    if id_unique(id, 'union', lineno):
        name_dict[id] = union_info(id, body, lineno)
982900
def t_identifier(self, s):
        '
        self.rv.append(Token(type='IDENTIFIER', attr=s))
687469
def _validate_id_types(self):
        ''''''

        for sequences in [self.uniparc_sequences, self.fasta_sequences, self.seqres_sequences, self.rosetta_sequences]:
            for chain_id, sequence in sequences.iteritems():
                sequence_id_types = set(map(type, sequence.ids()))
                if sequence_id_types:
                    assert(len(sequence_id_types) == 1)
                    assert(sequence_id_types.pop() == types.IntType)

        for chain_id, sequence in self.atom_sequences.iteritems():
            sequence_id_types = set(map(type, sequence.ids()))
            assert(len(sequence_id_types) == 1)
            sequence_id_type = sequence_id_types.pop()
            assert(sequence_id_type == types.StringType or sequence_id_type == types.UnicodeType)
740548
public void uniq() {
        if (size <= 1) { return; }
        int cursor = 0;
        for (int i=1; i<size; i++) {
            if (elements[cursor] != elements[i]) {
                cursor++;
                elements[cursor] = elements[i];
            }
        }
        size = cursor+1;
    }
288687
def _unique_id(self, prefix):
        
        _id = self._id_gen
        self._id_gen += 1
        return prefix + str(_id)
966105
function identifierFactory (ast, reserved) {
  reserved = reserved || new Set

  ast.find(j.Identifier).forEach(path => {
    reserved.add(path.node.name)
  })

  ast.find(j.FunctionDeclaration).forEach(path => {
    reserved.add(path.node.id.name)
  })

  function identifier (name, suffix) {
    return j.identifier(identifier.string(name, suffix))
  }

  identifier.string = function (name, suffix) {
    let sfx = suffix == null ? '' : suffix
      , unique = name + sfx
      , n = 0

    while (reserved.has(unique)) {
      unique = name + (n++) + sfx
    }

    return unique
  }

  return identifier
}
884612
def t_ID(self, t):
        '

        if t.value[0] == '~':
            t.type = 'TYVAR'
            t.value = t.value[1:]
        elif t.value in self.reserved_words:
            t.type = self.reserved_words[t.value]
        else:
            t.type = 'ID'

        return t
200844
def identifiers
      if @typecode < Composite
        GCCType.new( @typecode.element_type ).identifiers * @typecode.num_elements
      else
        [ GCCType.new( @typecode ).identifier ]
      end
    end