Concat the given prefixes into one.
510646
protected String concat(String first, String second) {
        return first == null ? second : String.format("%s.%s", first, second);
    }
1277395
function prepend(str, prefix) {
    if (!str && str !== 0) {
        str = '';
    } else {
        str = str.toString();
    }
    return prefix + str;
}
469619
function _concat(buffOne, buffTwo) {
  if (!buffOne) return buffTwo;
  if (!buffTwo) return buffOne;

  let newLength = buffOne.length + buffTwo.length;
  return Buffer.concat([buffOne, buffTwo], newLength);
}
850928
def _prepend_name_prefix(self, name):
        """"""
        if not self.name_prefix:
            return name
        base = self.name_prefix
        if base[0] != '/':
            base = '/' + base
        if name[0] != '/':
            name = '/' + name
        return base + name
659523
def prefix_list(self, prefix, values):
        
        return list(map(lambda value: prefix + " " + value, values))
1000188
private static void concat(double[] target, double[] first, int firstLength, double[] second, int secondLength)
    {
        System.arraycopy(first, 0, target, 0, firstLength);
        System.arraycopy(second, 0, target, firstLength, secondLength);
    }
709943
def prefix(tokens, operator_table):
    """"""
    operator, matched_tokens = operator_table.prefix.match(tokens)
    if operator:
        return TokenMatch(operator, None, matched_tokens)
506020
public Runnable concat(Runnable... runnables)
    {
        if (runnables.length == 0)
        {
            throw new IllegalArgumentException("empty");
        }
        Runnable r = runnables[runnables.length-1];
        for (int ii=runnables.length-2;ii>=0;ii--)
        {
            r = concat(runnables[ii], r);
        }
        return r;
    }
809081
@Nullable
    private static String concat(@Nullable String[] values, @NonNull String delimeter) {
        if (values == null || values.length == 0) {
            return null;
        }
        final StringBuilder str = new StringBuilder();
        for (String val : values) {
            str.append(val).append(delimeter);
        }
        str.delete(str.length() - delimeter.length(), str.length());
        return str.toString();
    }
1081297
def _find_common_prefix(self, node1, node2):
        """"""
        tokens1 = [item.strip() for item in node1.split(self.node_separator)]
        tokens2 = [item.strip() for item in node2.split(self.node_separator)]
        ret = []
        for token1, token2 in zip(tokens1, tokens2):
            if token1 == token2:
                ret.append(token1)
            else:
                break
        return self.node_separator.join(ret)
756165
private static String concat(final String... parts) {

		final StringBuilder buf = new StringBuilder();

		for (final String part : parts) {

			// handle nulls gracefully (ignore)
			if (part != null) {

				buf.append(part);
			}
		}

		return buf.toString();
	}
409811
def concat(other)
      other.rule_sets.each do |context_name, rule_set|
        add_rules_to_context(context_name, rule_set)
      end

      self
    end
1258301
public static <T> List<T> concat(List<List<T>> lists) {
        List<T> list = new ArrayList<T>();
        for (List<? extends T> l : lists) {
            list.addAll(l);
        }
        return list;
    }
204083
private String combine(String parent, String child) {
    if (parent.length() > 0) {
      return parent.concat(".").concat(child);
    } else {
      return child;
    }
  }
164328
def concatenate(self, others):
        """"""
        if not isinstance(others, (list, tuple)):
            others = others,
        tup = (self.values,) + tuple(o.values for o in others)
        out = np.concatenate(tup, axis=0)
        out = type(self)(out)
        return out
1227717
def concat_padded(base, *args):
    
    ret = base
    for n in args:
        if is_string(n):
            ret = "%s_%s" % (ret, n)
        else:
            ret = "%s_%04i"  % (ret, n + 1)
    return ret
700107
def prefix(*kinds):
    """"""
    def wrap(fn):
        try:
            fn.prefix_kinds.extend(kinds)
        except AttributeError:
            fn.prefix_kinds = list(kinds)
        return fn
    return wrap