Concatenate a value to this tuple.
176004
public final <T2> Tuple2<T1, T2> concat(T2 value) {
        return new Tuple2<>(v1, value);
    }
767231
private void append(final byte[] next_qualifier, final byte[] next_value) {
    ensureCapacity(next_qualifier, next_value);

    // Now let's simply concatenate all the values together.
    System.arraycopy(next_value, 0, batched_value, value_index, next_value.length);
    value_index += next_value.length;

    // Now let's concatenate all the qualifiers together.
    System.arraycopy(next_qualifier, 0, batched_qualifier, qualifier_index, 
        next_qualifier.length);
    qualifier_index += next_qualifier.length;
  }
32442
def append(self, value):
        
        if not self.need_free:
            raise ValueError("Stack is read-only")
        if not isinstance(value, X509):
            raise TypeError('StackOfX509 can contain only X509 objects')
        sk_push(self.ptr, libcrypto.X509_dup(value.cert))
39724
def append(self, value):
        """"""
        if self.asserted:
            raise RuntimeError("Fact already asserted")

        self._multifield.append(value)
679416
def concat(dfs):
    """"""
    if isstr(dfs) or not hasattr(dfs, '__iter__'):
        msg = 'Argument must be a non-string iterable (e.g., list or tuple)'
        raise TypeError(msg)

    _df = None
    for df in dfs:
        df = df if isinstance(df, IamDataFrame) else IamDataFrame(df)
        if _df is None:
            _df = copy.deepcopy(df)
        else:
            _df.append(df, inplace=True)
    return _df
292726
def append(self, val):
        
        self.values.append(val)
        self.value = self.values[0]
1117444
def concat(self, operand, start=0, end=0, offset=0):
        """"""
        if not Gauged.map_concat(self.ptr, operand.ptr, start, end, offset):
            raise MemoryError
1272391
def append(self, other):
        
        if not isinstance(other, (list, tuple)):
            other = [other]

        if all((isinstance(o, MultiIndex) and o.nlevels >= self.nlevels)
               for o in other):
            arrays = []
            for i in range(self.nlevels):
                label = self._get_level_values(i)
                appended = [o._get_level_values(i) for o in other]
                arrays.append(label.append(appended))
            return MultiIndex.from_arrays(arrays, names=self.names)

        to_concat = (self.values, ) + tuple(k._values for k in other)
        new_tuples = np.concatenate(to_concat)

        # if all(isinstance(x, MultiIndex) for x in other):
        try:
            return MultiIndex.from_tuples(new_tuples, names=self.names)
        except (TypeError, IndexError):
            return Index(new_tuples)
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);
    }
236515
public final <T5> Tuple5<T1, T2, T3, T4, T5> concat(Tuple1<T5> tuple) {
        return new Tuple5<>(v1, v2, v3, v4, tuple.v1);
    }
251986
def concat(self, formatted_text):
        """"""
        assert self._is_compatible(formatted_text), "Cannot concat text with different modes"
        self.text += formatted_text.text
        return self
1195559
def add(self, val):
        """"""
        _lists = self._lists
        _keys = self._keys
        _maxes = self._maxes

        key = self._key(val)

        if _maxes:
            pos = bisect_right(_maxes, key)

            if pos == len(_maxes):
                pos -= 1
                _lists[pos].append(val)
                _keys[pos].append(key)
                _maxes[pos] = key
            else:
                idx = bisect_right(_keys[pos], key)
                _lists[pos].insert(idx, val)
                _keys[pos].insert(idx, key)

            self._expand(pos)
        else:
            _lists.append([val])
            _keys.append([key])
            _maxes.append(key)

        self._len += 1
211908
def concat(self, one, two):
        """"""
        if not len(one) == len(two) == 6:
            raise ValueError("bad sequ. length")
        self.a, self.b, self.c, self.d, self.e, self.f = TOOLS._concat_matrix(one, two)
        return self
385108
def as_tuple(self, value):
        """"""
        if isinstance(value, list):
            value = tuple(value)
        return value
1097821
public final <T2, T3> Tuple3<T1, T2, T3> concat(Tuple2<T2, T3> tuple) {
        return new Tuple3<>(v1, tuple.v1, tuple.v2);
    }
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,)
184669
def _append(self, target, value):
        
        return self.__p(target) + '[] = ' + self.__p(value) + ';'