Create a concrete version of the concatenated string
    :param args: List of string that has to be concatenated

    :return : a concrete version of the concatenated string
337046
def StrConcat(*args):
    
    new_value = ''.join([arg.value for arg in args])
    return StringV(new_value)
1113481
def concat(self, *args, **kwargs):
        
        for arg in args:
            assert self.formatted_text._is_compatible(arg), "Cannot concat text with different modes"
            self.format_args.append(arg.text)
        for kwarg in kwargs:
            value = kwargs[kwarg]
            assert self.formatted_text._is_compatible(value), "Cannot concat text with different modes"
            self.format_kwargs[kwarg] = value.text
        return self
1350814
def p_args(p):
    
    if len(p) == 2:
        p[0] = node.expr_list([p[1]])
    else:
        p[0] = p[1]
        p[0].append(p[2])
350737
def _stringlist(*args):
    
    return list(itertools.chain.from_iterable(itertools.repeat(x,1) if stringy(x) else x for x in args if x))
761523
def kwargs_to_string(kwargs):
    
    outstr = ''
    for arg in kwargs:
        outstr += ' -{} {}'.format(arg, kwargs[arg])
    return outstr
702389
def fill_arg(self, *args):
        
        missing = self.missing_vars()
        if len(args) == len(missing) == 1:
            self.setval(missing[0], args[0])
766246
def format_cmd(args):
    
    if args is None:
        return ''
    out = ''
    if not isinstance(args, list):
        args = [str(args)]
    for arg in args:
        if out != '':
            out += ' '
        out += pipes.quote(str(arg))
    return out
417345
def _build(self, *args):
    
    net = args

    if not self._layers:
      # If the sequential is passed a single arg, this will end up being
      # wrapped in an extra layer of tuple by *args. Normally we internally
      # handle this in the loop below, but if there are no layers we unpack here
      # in order to make Sequential([]) act like an identity, which seems right.
      if len(args) == 1:
        return args[0]
      else:
        return args

    for layer in self._layers:
      if isinstance(net, tuple):
        net = layer(*net)
      else:
        net = layer(net)

    return net
8215
def _expected_argument_string(self):
        

        if self.args is _any and self.kwargs is _any:
            return 'any args'
        elif self._custom_matcher:
            return "custom matcher: '{}'".format(self._custom_matcher.__name__)
        else:
            return build_argument_repr_string(self.args, self.kwargs)
769336
def _process_arguments(self, arguments):
        
        if not arguments:
            return None
        a = arguments.split(" :", 1)
        arglist = a[0].split()
        if len(a) == 2:
            arglist.append(a[1])
        return arglist
881277
def str_args(args):
    
    res = []
    for x in args:
        if isinstance(x, tuple) and len(x) == 2:
            key, value = x
            if value and str_arg(value):
                res += ["%s=%s" % (key, str_arg(value))]
        else:
            res += [str_arg(x)]
    return ', '.join(res)
430531
Append append(String format, Object... args) {
    return append(String.format(format, args));
  }
932494
def extend(*args):
    
    if not args:
        return {}

    first = args[0]
    rest = args[1:]
    out = type(first)(first)
    for each in rest:
        out.update(each)
    return out
1055289
def concatenate(ctx, *text):
    
    result = ''
    for arg in text:
        result += conversions.to_string(arg, ctx)
    return result
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
213766
def give_str(self):
        
        args = self._args[:]
        kwargs = self._kwargs
        return self._give_str(args, kwargs)
594372
private static String convertArgs(String[] args)
    {
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < args.length; i++)
        {
            result.append(args[i]);
            if (i < args.length - 1)
            {
                result.append(' ');
            }
        }
        return result.toString().toUpperCase();
    }