Path: csiph.com!fu-berlin.de!uni-berlin.de!not-for-mail
From: Ethan Furman <ethan@stoneleaf.us>
Newsgroups: comp.lang.python
Subject: Re: Namespaces are one honking great idea
Date: Fri, 01 Jul 2016 09:00:44 -0700
Lines: 120
Message-ID: <mailman.2.1467388849.2295.python-list@python.org>
References: <57767a97$0$1606$c3e8da3$5496439d@news.astraweb.com> <577693AC.6090807@stoneleaf.us>
Mime-Version: 1.0
Content-Type: text/plain; charset=windows-1252; format=flowed
Content-Transfer-Encoding: 7bit
User-Agent: Mozilla/5.0 (X11; Linux i686; rv:31.0) Gecko/20100101 Thunderbird/31.2.0
In-Reply-To: <57767a97$0$1606$c3e8da3$5496439d@news.astraweb.com>
Precedence: list
Xref: csiph.com comp.lang.python:110907

On 07/01/2016 07:13 AM, Steven D'Aprano wrote:

I like the idea, but I have a couple questions about the design choices. 
  Comments below.

> The Zen of Python says:
>
>      Namespaces are one honking great idea -- let's do more of those!

> Proposal
> =========
>
> Add a new "namespace" object to Python.


> Proof of concept
> =================
>
> Here's a proof of concept. I use a class with a custom metaclass like this:
>
>
> # Python 3 version
> class ExampleNS(metaclass=Namespace):
>      x = 1
>      y = []
>
>      def spam(n):
>          return 'spam'*n
>
>      z = spam(3).upper()
>
>      def ham(n):
>          return spam(n).replace('sp', 'H')
>
>      def test():
>          global x
>          x += 1
>          y.append(1)
>          return x, y
>

> Despite the "class" statement (a limitation of Python's lack of dedicated
> syntax for namespaces), the Example namespace behaves like (in fact, *is*)
> a module embedded inside a module.

So the idea is to have several "mini-modules" inside a single file?

Can a mini-module function access a different mini-module's function?

Can a mini-module function access/interact with the module's global scope?

> Especially note that inside the namespace, the global statement makes a name
> refer to the namespace scope.

Interesting.  :)


> Unresolved questions
> =====================
>
> Would a decorator be better than a metaclass?

I think a decorator may provide more of a clue that something 
interesting is happening -- whether a decorator is feasible depends on 
whether you need the __prepare__ magic of metaclasses.

>      @namespace
>      class Example:
>          ...

I believe Python already has a NameSpace type, so a different name is 
probably better.  How about minimodule? ;)


> Some limitations
> =================
>
> The simplified implementation shown doesn't allow functions inside the
> namespace to access names outside of the namespace easily.

How not-easy is it?

> In practice, the
> user might want the name resolution order inside the namespace to be:
>
>   local variables
>   nonlocal variables
>   namespace globals
>   module globals
>   builtins

That would be ideal, I think.  How close can we get to that?

> The biggest limitation is that I have to abuse the class statement to do
> this. In an ideal world, there would be syntactic support and a keyword:
>
>      namespace Example:
>          x = 0
>          y = []
>          def test(n): ...
>
> although others might argue that *not* needing a dedicated keyword is, in
> fact, better.

Metaclasses for the win!

> Disadvantages
> ==============
>
> Those unfamiliar with the namespace concept may be confused by a class that
> doesn't get instantiated.

A well-named decorator/base-class should help with that.


Did you mean for this to go to -Ideas?

--
~Ethan~