s/stry,bytes,unicode/string_types,text_types/

this is not compatible across python versions use text_strings, byte_strings from our 'compatiblity' code instead

generator, not gnerator

Camel case and underscores? :)

sometimes you have to allow for all kinds ...

We could make this more efficient. what types can be given here? Since the original jinja2 code is u"".join(invals) it seems like the minimum assumptions we can make are that invals is an iterable and that all the elements can convert to a text type without unicode exceptions. So maybe something like this:

# We can omit this block if invals is never a string type
if isinstance(invals, six.text_type):
    return invals
elif isinstance(invals, six.binary_type):
    return to_text(invals, errors='surrogate_or_strict')

try:
    if len(invals) == 1:
        # Break out the single value
        return invals[0]
except TypeError:
    # Iterable (by contract) but not a Sequence
    pass

return u''.join(invals)

• This keeps us from instantiating two lists.
• This should be faster even than the jinja2 concat if strings (not inside of a container) are allowed as invals.
• If we don't have to deal with strings, then we can get rid of that block and reduce the number of conditionals.

I can adapt that further if we need to make less assumptions (or if we can make more of them).

Okay, jctanner says that this is always a generator. So this is a better implementation:

from itertools import chain
start = []
for val in invals:
    start.append(val)
    if len(start) > 1:
        break
else:
    if start:
        return start[0]
    return []      
return u''.join(chain(start, invals))

Profiling and jctanner's version is faster. So the only things I can see to do differently:

• remove "if isinstance(invals, list):". after the list comprehension, invals should always be a list.
• u'%s' % x for x in invals note that this isn't 100% safe (for instance b'café' will raise a unicode error) but I assume you took it from some part of jinja2 code so we aren't making a new assumption then.