[Python-ideas] a simple namespace type

[Eric Snow]

On Thu, May 24, 2012 at 12:14 PM, Guido van Rossum <guido at python.org> wrote:
> On Thu, May 24, 2012 at 10:17 AM, Eric Snow <ericsnowcurrently at gmail.com> wrote:
>>  Effectively this is just a simple but distinct facade around dict to
>> give a namespace with attribute access.  I suppose part of the
>> question is how much of the Mapping interface would belong instead to
>> a hypothetical Namespace interface. (I'm definitely _not_ proposing
>> such an unnecessary extra level of abstraction).
>
> Possibly there is a (weird?) parallel with namedtuple. The end result
> is somewhat similar: you get to use attribute names instead of the
> accessor syntax (x[y]) of the underlying type. But the "feel" of the
> type is different, and inherits more of the underlying type
> (namedtuple is immutable and has a fixed set of keys, whereas the type
> proposed here is mutable and allows arbitrary keys as long as they
> look like Python names).

Yeah, the feel is definitely different.  I've been thinking about this
because of the code for sys.implementation.  Using a structseq would
probably been the simplest approach there, but a named tuple doesn't
feel right.  In contrast, a SimpleNamespace would fit much better.

As far as this goes generally, the pattern of a simple, dynamic
attribute-based namespace has been implemented a zillion times (and
it's easy to do).  This is because people find a simple dynamic
namespace really handy and they want the attribute-access interface
rather than a mapping.

In contrast, a namedtuple is, as Nick said, "the standard library's
answer for structured records".  It's an immutable (attribute-based)
namespace implementing the Sequence interface.  It's a tuple and
directly reflects the underlying concept of tuples in Python by giving
the values names.

SimpleNamespace (and the like) isn't a structured record.  It's only
job is to be an attribute-based namespace with as simple an interface
as possible.

So why isn't a type like SimpleNamespace in the stdlib? Because it's
trivial to implement.  There's a certain trivial-ness threshold a
function/type must pass before it gets canonized, and rightly so.

Anyway, while many would use something like SimpleNamespace out the
the standard library, my impetus was having it as a builtin type so I
could use it for sys.implementation.  :)

FWIW, I have an implementation (pure Python + c extension) of
SimpleNamespace on PyPI:

  http://pypi.python.org/pypi/simple_namespace

-eric