:param val_list: a list of strings
    :return: a list of upper-cased strings
975772
def _upper(val_list):
    
    res = []
    for ele in val_list:
        res.append(ele.upper())
    return res
743527
function normalizeList (val, name) {
  var list = [].concat(val || [])

  for (var i = 0; i < list.length; i++) {
    if (typeof list[i] !== 'string') {
      throw new TypeError(name + ' must be array of strings or false')
    }
  }

  return list
}
414046
def list2string (inlist,delimit=' '):
    
    stringlist = [makestr(_) for _ in inlist]
    return string.join(stringlist,delimit)
1286147
def __stringlist(self, ttype, tvalue):
        
        if ttype == "string":
            self.__curstringlist += [tvalue.decode("utf-8")]
            self.__set_expected("comma", "right_bracket")
            return True
        if ttype == "comma":
            self.__set_expected("string")
            return True
        if ttype == "right_bracket":
            self.__curcommand.check_next_arg("stringlist", self.__curstringlist)
            self.__cstate = self.__arguments
            return self.__check_command_completion()
        return False
518930
def get_python_list(scala_list):
    """"""
    python_list = []
    for i in range(scala_list.length()):
        python_list.append(scala_list.apply(i))
    return python_list
718261
def list_fonts():
    
    vals = _list_fonts()
    for font in _vispy_fonts:
        vals += [font] if font not in vals else []
    vals = sorted(vals, key=lambda s: s.lower())
    return vals
1005954
def _validate_str_list(arg):
    '''
    
    '''
    if isinstance(arg, six.binary_type):
        ret = [salt.utils.stringutils.to_unicode(arg)]
    elif isinstance(arg, six.string_types):
        ret = [arg]
    elif isinstance(arg, Iterable) and not isinstance(arg, Mapping):
        ret = []
        for item in arg:
            if isinstance(item, six.string_types):
                ret.append(item)
            else:
                ret.append(six.text_type(item))
    else:
        ret = [six.text_type(arg)]
    return ret
880173
def top_n_list(lang, n, wordlist='best', ascii_only=False):
    
    results = []
    for word in iter_wordlist(lang, wordlist):
        if (not ascii_only) or max(word) <= '~':
            results.append(word)
            if len(results) >= n:
                break
    return results
1120683
def pretty_print_list(lst, name = 'features', repr_format=True):
    
    if not lst or len(lst) < 8:
        if repr_format:
            return lst.__repr__()
        else:
            return ', '.join(map(str, lst))
    else:
        topk = ', '.join(map(str, lst[:3]))
        if repr_format:
            lst_separator = "["
            lst_end_separator = "]"
        else:
            lst_separator = ""
            lst_end_separator = ""

        return "{start}{topk}, ... {last}{end} (total {size} {name})".format(\
                topk = topk, last = lst[-1], name = name, size = len(lst),
                start = lst_separator, end = lst_end_separator)
652267
def append(self, val):
        
        # pylint: disable=arguments-differ
        _lists = self._lists
        _maxes = self._maxes

        if not _maxes:
            _maxes.append(val)
            _lists.append([val])
            self._len = 1
            return

        pos = len(_lists) - 1

        if val < _lists[pos][-1]:
            msg = '{0!r} not in sort order at index {1}'.format(val, self._len)
            raise ValueError(msg)

        _maxes[pos] = val
        _lists[pos].append(val)
        self._len += 1
        self._expand(pos)
662919
def list_all_eq_to(list_, val, strict=True):
    
    if util_type.HAVE_NUMPY and isinstance(val, np.ndarray):
        return all([np.all(item == val) for item in list_])
    try:
        # FUTURE WARNING
        # FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
        with warnings.catch_warnings():
            warnings.filterwarnings('ignore', category=FutureWarning)
            flags = [item == val for item in list_]
            return all([np.all(flag) if hasattr(flag, '__array__') else flag
                        for flag in flags])
        #return all([item == val for item in list_])
    except ValueError:
        if not strict:
            return all([repr(item) == repr(val) for item in list_])
        else:
            raise
1242323
def force_string(val=None):
    
    if val is None:
        return ''
    if isinstance(val, list):
        newval = [str(x) for x in val]
        return ';'.join(newval)
    if isinstance(val, str):
        return val
    else:
        return str(val)
1185764
def p_case_list(self, p):
        ''''''
        if len(p) == 4:
            p[1].append(p[3])
            p[0] = p[1]
        elif len(p) == 2:
            p[0] = [p[1]]
841625
def _convert_to_list(self, value, delimiters):
        
        if not value:
            return []
        if delimiters:
            return [l.strip() for l in value.split(delimiters)]
        return [l.strip() for l in value.split()]
1099356
def list2str(self, l: List, joiner: str) -> str:
        
        result = str()
        for item in l:
            if isinstance(item, list):
                result = result + self.list2str(item, joiner) + joiner
            elif isinstance(item, dict):
                result = result + self.dict2str(item, joiner) + joiner
            elif item:
                result = result + str(item) + joiner
        return result
208313
public static int listFindNoCase(String list, String value, String delimiter) {
	return listFindNoCase(list, value, delimiter, true);
    }
972192
def make_all_uppercase(
            lst: Union[list, tuple, str, set]
    ) -> Union[list, tuple, str, set]:
        
        if not isinstance(lst, (list, tuple, str, set)):
            raise TypeError('lst must be a list, a tuple, a set or a string')

        if isinstance(lst, str):
            return lst.upper()

        arr = list(lst)

        # enumerate is 70% slower than range
        # for i in range(len(lst)):
        #     if isinstance(arr[i], (list, tuple, str, set)):
        #         arr[i] = Aux.make_all_uppercase(arr[i])
        arr[:] = [
            Aux.make_all_uppercase(element) if (
                isinstance(element, (list, tuple, str, set))
            ) else element for element in arr
        ]

        if isinstance(lst, set):
            return set(arr)
        elif isinstance(lst, tuple):
            return tuple(arr)

        return arr