Add +tuple+ to the TupleBag.
506856
def push(tuple)
      key = bin_key(tuple)
      @hash[key] ||= TupleBin.new
      @hash[key].add(tuple)
    end
550016
def flatten(l):
    """"""
    return sum(map(flatten, l), []) \
        if isinstance(l, list) or isinstance(l, tuple) else [l]
478727
def add(self, *number):
        """"""
        return self._format_result(sum(
            # positional arguments are always strings
            [int(n) for n in number]))
1127801
def add(self, item):
        """"""
        if not item in self.items:
            self.items.append(item)
1365906
def _make_tuple(x):
  """"""
  if isinstance(x, prettytensor.PrettyTensor):
    if x.is_sequence():
      return tuple(x.sequence)
    else:
      return (x.tensor,)
  elif isinstance(x, tuple):
    return x
  elif (isinstance(x, collections.Sequence) and
        not isinstance(x, six.string_types)):
    return tuple(x)
  else:
    return (x,)
1117745
public final <T1, T2, T3, T4> Tuple4<T1, T2, T3, T4> concat(Tuple4<T1, T2, T3, T4> tuple) {
        return new Tuple4<>(tuple.v1, tuple.v2, tuple.v3, tuple.v4);
    }
738008
def _add_from_list(self, l):
        

        for item in l:
            if isinstance(item, (str, ustr)):
                self._add_from_str(item)
            elif isinstance(item, (list, tuple)):
                location = Location(item)
                self._add_location(location)
50786
public void addTupleInput(Path path, Schema targetSchema, MapOnlyMapper tupleMapper) {
		addInput(path, new TupleInputFormat(targetSchema), tupleMapper);
	}
110964
def _addTags(self, **k):
        """"""

        for tag, thing in k.items():
            if not isinstance(thing, (tuple, list)):
                thing = (thing,)
            typetag = defaulttagtype[tag]
            self.rawtagdict[tag] = encode(typetag, *thing)
        return self
931417
def add(self, dic):
        '''
        '''
        for kw in dic:
            checkKey(kw, self.keyWord)
            self._add([Pair(kw, StringSingle(dic[kw]))], self.d)
700132
def to_tuple(self, iterable, surround="()", joiner=", "):
    """"""
    return "{0}{1}{2}".format(surround[0], joiner.join(iterable), surround[1])
1238721
def generic_add(a, b):
    """"""
    logger.debug('Called generic_add({}, {})'.format(a, b))
    return a + b
529809
function tuple5Of(a, b, c, d, e) {
    var self = getInstance(this, tuple5Of);
    self.types = rest(arguments);
    return self;
}
1135157
public MapPBag<E> plus(final E e) {
		return new MapPBag<E>(map.plus(e, count(e)+1), size+1);
	}
1164621
protected function addBagDataToSession()
    {
        $bags = array_merge($this->bags, array($this->metaBag));

        foreach ($bags as $bag) {
            $name = $bag->getStorageKey();

            $this->put($name, $this->getBagData($name));
        }
    }
44193
Expr addSub() {
		Expr expr = mulDivMod();
		for (Tok tok=peek(); tok.sym==Sym.ADD || tok.sym==Sym.SUB; tok=peek()) {
			move();
			expr = new Arith(tok.sym, expr, mulDivMod(), location);
		}
		return expr;
	}
172692
def _make_tuple(self, env):
    """"""
    t = runtime.Tuple(self, env, dict2tuple)
    # A tuple also provides its own schema spec
    schema = schema_spec_from_tuple(t)
    t.attach_schema(schema)
    return t