Path: csiph.com!v102.xanadu-bbs.net!xanadu-bbs.net!feeder.erje.net!eu.feeder.erje.net!news.stack.nl!newsfeed.xs4all.nl!newsfeed1a.news.xs4all.nl!xs4all!newsgate.cistron.nl!newsgate.news.xs4all.nl!post.news.xs4all.nl!not-for-mail
MIME-Version: 1.0
In-Reply-To: <CAPTjJmpYBVcHPotvyb+e3QExDOhXc9J2xO5VY1aow8mQcUxVRQ@mail.gmail.com>
References: <CAPTjJmpYBVcHPotvyb+e3QExDOhXc9J2xO5VY1aow8mQcUxVRQ@mail.gmail.com>
From: Chris Kaynor <ckaynor@zindagigames.com>
Date: Mon, 18 Aug 2014 09:53:23 -0700
Subject: Re: Module-level functions and the module type
To: Chris Angelico <rosuav@gmail.com>
Content-Type: multipart/alternative; boundary=e89a8f646fcfaebf0b0500ea3686
Cc: "python-list@python.org" <python-list@python.org>
Precedence: list
Newsgroups: comp.lang.python
Message-ID: <mailman.13102.1408380830.18130.python-list@python.org>
Lines: 118
NNTP-Posting-Host: 2001:888:2000:d::a6
Xref: csiph.com comp.lang.python:76486

--e89a8f646fcfaebf0b0500ea3686
Content-Type: text/plain; charset=UTF-8

On Sun, Aug 17, 2014 at 8:15 AM, Chris Angelico <rosuav@gmail.com> wrote:

> In a class definition, you have explicit state parameters on your
> functions - 'self':
>
> class C:
>     def foo(self, arg):
>         # blah blah
>
> At module level, there's equivalent state - the function "knows" what
> module it came from - but it's implicit:
>
> def foo(arg):
>     # blah blah
>
> print(foo.__globals__)
>
> How hard would it be to unify these, and make modules into classes?
> This would then allow stuff like properties, metaclasses, and so on,
> all with exactly the same semantics as they have in classes.
>
> Obviously this would be a huge backward-compatibility break if it
> happened everywhere, but what I'm looking at here is a way to
> basically bless this kind of concept:
>
> # spam.py
> class RealSpam:
>     # module contents here
>
> import sys
> sys.modules[__name__] = RealSpam()


> So the question is: Why is state implicit in one and explicit in the
> other? Which option is really the better way to do things?
>

As a heads up, we did this at work (mostly, just to support module-level
properties) by using an import hook to adjust the type of object loaded
from .py files. At the root, it was fairly easy to implement (though quite
a bit of boiler code), however the main problem we ran into was performance
- doing so slowed down all module accesses.

The other issue with the way we did it (we didn't pass in the module to all
functions) was that global accesses would not access the properties, so
work-arounds had to be done to access them within the module itself.

Chris

--e89a8f646fcfaebf0b0500ea3686
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><div class=3D"gmail_extra"><div class=3D"gmail_quote">On S=
un, Aug 17, 2014 at 8:15 AM, Chris Angelico <span dir=3D"ltr">&lt;<a href=
=3D"mailto:rosuav@gmail.com" target=3D"_blank">rosuav@gmail.com</a>&gt;</sp=
an> wrote:<br>


<blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-=
left-width:1px;border-left-color:rgb(204,204,204);border-left-style:solid;p=
adding-left:1ex">In a class definition, you have explicit state parameters =
on your<br>



functions - &#39;self&#39;:<br>
<br>
class C:<br>
=C2=A0 =C2=A0 def foo(self, arg):<br>
=C2=A0 =C2=A0 =C2=A0 =C2=A0 # blah blah<br>
<br>
At module level, there&#39;s equivalent state - the function &quot;knows&qu=
ot; what<br>
module it came from - but it&#39;s implicit:<br>
<br>
def foo(arg):<br>
=C2=A0 =C2=A0 # blah blah<br>
<br>
print(foo.__globals__)<br>
<br>
How hard would it be to unify these, and make modules into classes?<br>
This would then allow stuff like properties, metaclasses, and so on,<br>
all with exactly the same semantics as they have in classes.<br>
<br>
Obviously this would be a huge backward-compatibility break if it<br>
happened everywhere, but what I&#39;m looking at here is a way to<br>
basically bless this kind of concept:<br>
<br>
# spam.py<br>
class RealSpam:<br>
=C2=A0 =C2=A0 # module contents here<br>
<br>
import sys<br>
sys.modules[__name__] =3D RealSpam()</blockquote><blockquote class=3D"gmail=
_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left-width:1px;border-left=
-color:rgb(204,204,204);border-left-style:solid;padding-left:1ex">
<br>
So the question is: Why is state implicit in one and explicit in the<br>
other? Which option is really the better way to do things?<br></blockquote>=
<div>=C2=A0</div><div>As a heads up, we did this at work (mostly, just to s=
upport module-level properties) by using an import hook to adjust the type =
of object loaded from .py files. At the root, it was fairly easy to impleme=
nt (though quite a bit of boiler code), however the main problem we ran int=
o was performance - doing so slowed down all module accesses.</div>


<div><br></div><div>The other issue with the way we did it (we didn&#39;t p=
ass in the module to all functions) was that global accesses would not acce=
ss the properties, so work-arounds had to be done to access them within the=
 module itself.</div>

<div><br></div><div>Chris</div></div></div></div>

--e89a8f646fcfaebf0b0500ea3686--