How can we write a `__getitem__` method which accepts any iterable as input, and chains the items together?

Basic idea

Instead of making a separate container type, make a view for containers. The semantics are:

• A view instance tracks some iterable (which might be an element of some other iterable). For simplicity, we won’t bother checking whether it’s a proper container type or lazily evaluated.

• When the view is indexed with a value of a non-iterable type, it indexes into the container with that value.

• When the view is indexed with a value of an iterable type, it repeats the indexing for each element in that value.

• If the result of the indexing is iterable, the result is a view around that iterable. Otherwise, the result is the value itself.

It can be implemented quite simply:

class View:
    def __init__(self, data):
        self._data = data

    def __getitem__(self, indices):
        result = self._data
        # We can't easily distinguish a `TypeError` due to `indices`
        # being a non-iterable, from a `TypeError` due to reaching a 
        # leaf in the data prematurely. So we explicitly check first.
        try:
            iter(indices)
        except TypeError:
            result = result[indices]
        else:
            for i in indices:
                result = result[i]
        # Now decide whether to wrap the result
        try:
            iter(result)
        except TypeError:
            return result
        else:
            return View(result)

As a refactoring, we could use __new__ rather than __init__ so that the argument is returned unchanged if it isn’t iterable. That prevents explicitly creating bad Views, and can also simplify the __getitem__ logic:

class View:
    def __new__(cls, data):
        try:
            iter(data)
            result = object.__new__(cls)
            result._data = data
        except TypeError:
            result = data
        return result

    def __getitem__(self, indices):
        result = self._data
        try:
            iter(indices)
        except TypeError:
            result = result[indices]
        else:
            for i in indices:
                result = result[i]
        return View(result)

Special cases

There are two problems with this result compared to the specification:

1. slice objects are not actually iterable. We want to interpret myview[3:20:8] as if it were actually being indexed with the values described by that range, in sequence. Fortunately, it is trivial to convert a slice into the corresponding range object with the same start, stop and step.

   However, we need to complain if the start or stop are unspecified, since otherwise the semantics don’t make any sense; and we have to keep in mind that ranges don’t accept None as a step value (slices treat it as equivalent to 1). Finally, we have to accept that negative values will not index from the end, since again it will be far too difficult to interpret what should happen for all the corner cases.

2. Strings (and possibly other types) are iterable, and the elements are themselves non-empty strings – thus they can be indexed into arbitrarily many times. We need to special-case these in order for them to work as leaf nodes.

We need helper logic to treat strings as if they were not iterable. It should apply to construction, too (since otherwise we could make a totally useless View instance from a string). We don’t want that logic to handle slices, because View(slice(0)) should give us the original slice back, not a range.

With some refactoring, we get:

def _make_range(a_slice):
    start, stop, step = a_slice.start, a_slice.stop, a_slice.step
    if start is None or stop is None:
        raise ValueError('start and stop must be defined to convert to range')
    return range(start, stop, 1 if step is None else step)

def _non_string_iterable(obj):
    try:
        iter(data)
        return not isinstance(obj, str)
    except TypeError:
        return False

class View:
    def __new__(cls, data):
        if _non_string_iterable(data):
            result = object.__new__(cls)
            result._data = data
            return result
        return data

    def __getitem__(self, indices):
        result = self._data
        if isinstance(indices, slice):
            indices = _make_range(indices)
        if _non_string_iterable(indices):
            for i in indices:
                result = result[i]
        else:
            result = result[indices]
        return View(result)