[Python-ideas] @classproperty, @abc.abstractclasspropery, etc.

[K. Richard Pixley]

There's a whole matrix of these and I'm wondering why the matrix is 
currently sparse rather than implementing them all.  Or rather, why we 
can't stack them as:

class foo(object):
     @classmethod
     @property
     def bar(cls, ...):
         ...

Essentially the permutation are, I think: 
{'unadorned'|abc.abstract}{'normal'|static|class}{method|property|non-callable 
attribute}.

concreteness
	implicit first arg
	type
	name
	comments
{unadorned}
	{unadorned}
	method
	def foo():
	exists now
{unadorned} 	{unadorned} 	property
	@property
	exists now
{unadorned} 	{unadorned} 	non-callable attribute
	x = 2
	exists now
{unadorned} 	static
	method 	@staticmethod
	exists now
{unadorned} 	static 	property 	@staticproperty
	proposing
{unadorned} 	static 	non-callable attribute 	{degenerate case - 
variables don't have arguments}
	unnecessary
{unadorned} 	class
	method 	@classmethod
	exists now
{unadorned} 	class 	property 	@classproperty or @classmethod;@property
	proposing
{unadorned} 	class 	non-callable attribute 	{degenerate case - variables 
don't have arguments}
	unnecessary
abc.abstract 	{unadorned} 	method 	@abc.abstractmethod
	exists now
abc.abstract 	{unadorned} 	property 	@abc.abstractproperty
	exists now
abc.abstract 	{unadorned} 	non-callable attribute 
@abc.abstractattribute or @abc.abstract;@attribute
	proposing
abc.abstract 	static 	method 	@abc.abstractstaticmethod
	exists now
abc.abstract 	static 	property 	@abc.staticproperty
	proposing
abc.abstract 	static 	non-callable attribute 	{degenerate case - 
variables don't have arguments} 	unnecessary
abc.abstract 	class 	method 	@abc.abstractclassmethod
	exists now
abc.abstract 	class 	property 	@abc.abstractclassproperty
	proposing
abc.abstract 	class 	non-callable attribute 	{degenerate case - 
variables don't have arguments} 	unnecessary


I think the meanings of the new ones are pretty straightforward, but in 
case they are not...

@staticproperty - like @property only without an implicit first 
argument.  Allows the property to be called directly from the class 
without requiring a throw-away instance.

@classproperty - like @property, only the implicit first argument to the 
method is the class.  Allows the property to be called directly from the 
class without requiring a throw-away instance.

@abc.abstractattribute - a simple, non-callable variable that must be 
overridden in subclasses

@abc.abstractstaticproperty - like @abc.abstractproperty only for 
@staticproperty

@abc.abstractclassproperty - like @abc.abstractproperty only for 
@classproperty

--rich


-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/python-ideas/attachments/20110103/81b36cee/attachment.html>