On Jan 12, 3:52 pm, mabshoff <michael.absh...@mathematik.uni-
dortmund.de> wrote:
> On Jan 12, 6:04 am, "Nicolas M. Thiery" <nicolas.thi...@u-psud.fr>
> wrote:
>
> Hi Nicolas,
>
> > > > Discussion about the usage of (lazy) attributes w.r.t
> > > > parameterless methods i.e. f.bla or f.bla()
> > > Well, one objection is that the lazy attributes don't work in Cython
>
> > As the examples show, this discussion concerns mostly parents; those
> > rarely need to be written in cython. If this really became needed, we
> > probably can make lazy attributes work in cython.
>
> > > and that it feels totally different from how the rest of Sage works.
>
> > I am seriously considering changing all of Sage here :-)
>
> Well, maybe Sage needs to change you :)
>
> [Insert joke: "In Soviet Russia Sage changes you!"]
>
> > (which is the kind of mood you get in when working on a general
> > purpose category infrastructure).
>
> > > Also, always using methods is consistent whereas I think it'd be
> > > difficult to find a predictable scheme for distinguishing between
> > > when things should be attributes and when they should be methods.
>
> > Indeed. But we gain much in readability:
>
> > S.s()[3,1] w.r.t. S.s[3,1]
>
> > R.root_lattice().simple_roots()[3] w.r.t.
> > R.root_lattice.simple_roots[3]
>
> This is very unpythonic IMHO and I doubt you could convince a majority
> of something like that to go in. Before working on this more you might
> want to raise the issue on sage-devel.
My opinion is that this suggestion *is* very Pythonic. It however is
*not* very "Sage-onic", simply because rarely in Sage do we ever use
properties, which are Python attributes that are read only or with a
function that controls their setting, and for which accessing them
computes them on the fly. Properties are a core feature of Python
though (introduced I think in Python 2.4).
Here's why Sage doesn't use properties much:
(1) They were in Python yet when I started Sage.
(2) They *really* suck when it comes to interactive introspection,
e.g., try
sage: R.root_lattice?
above and instead of get docs on the root_lattice function, you get
docs on the root_lattice itself.
This can be *very* annoying in some cases, e.g., if you have a number
x, then x.sign? would give
you docs on the number +1 or -1, instead of on what the sign
"function" does.
(3) I think users find it confusing that sometimes they type x.foo
and other times they type x.bar(). No matter how much you use
properties, you will *still* have functions, e.g., because of default
arguments. So instead of users just learning the rule to put
parenthesis after they call something, they have to guess -- do I
wrote "x.foo" or "x.foo()"? And doing x.foo? will only help them
half the time as mentioned in 2 above; moreover, doing x.foo() when
they should do x.foo will yield completely surprising behavior (it
would be like x.foo()() now).
In short, I think properties are perfectly fine for code that won't be
used interactively and in an exploratory way, like the majority of
"normal" python code out there. However, for Sage I think there are
several problems with them, which one realizes if you have spent a
*lot* of time watching over the shoulders of users as they try to use
Sage.
-- William
>
> > Besides, I find that the second conveys more information: the
> > simple_roots are really part of the description of the root lattice.
>
> > Cheers,
> > Nicolas
>
> Cheers,
>
> Michael
>
> > --
> > Nicolas M. Thiéry "Isil" <nthi...@users.sf.net>http://Nicolas.Thiery.name/
--~--~---------~--~----~------------~-------~--~----~
To post to this group, send email to sage-devel@googlegroups.com
To unsubscribe from this group, send email to
sage-devel-unsubscr...@googlegroups.com
For more options, visit this group at http://groups.google.com/group/sage-devel
URLs: http://www.sagemath.org
-~----------~----~----~----~------~----~------~--~---
