role-exclusion

[gitmo/Moose.git] / TODO

-------------------------------------------------------------------------------
TODO
-------------------------------------------------------------------------------

- roles

Need to figure out the details of composite roles

- type unions

Add support for doing it with Classes which do not have 
a type constraint yet created

- type intersections

Mostly just for Roles

- inherited slot specs

'does' can be added to,.. but not changed
(need type unions for this)

- proxy attributes

a proxied attribute is an attribute
which looks like an attribute, 
talks like an attribute, smells 
like an attribute,.. but if you 
look behind the curtain,.. its 
over there.. in that other object

(... probably be a custom metaclass)

- compile time extends

[00:39] 	sri	    but maybe a better syntax for compile time extends
[00:39] 	stevan	I have been pondering that actually
[00:39] 	sri	    use Moose extends => Foo::Bar
[00:40] 	stevan	I think now that we have the Sub::Exporter stuff 
                    in, that kinda thing should be pretty easy

nothingmuch notes that all the constructs should be supported in the entirety of the use clause:

    use Moose (
        has => foo (
            ....
        ),
    );

and that if this usage style is used nothing is exported to the namespace.

- default should dclone()

- subtype $anon_subtype => where { ... }

[22:56] 	stevan	sub mst_doesnt_like_to_type { (shift)->meta->attr->type_contstraint }
[22:57] 	mst	err
[22:57] 	stevan	:P
[22:57] 	stevan	are you wanting to reuse it or something?
[22:57] 	stevan	my $subtype = subtype 'Something' => where { ... };
[22:58] 	stevan	then you can do isa => $subtype 
[22:58] 	mst	but I can't subtype it again
[22:59] 	stevan	mst: ahhh... 
[22:59] 	mst	well, I can. but it suddenly gets very "long way round" ish
[23:00] 	stevan	my $constraint = Moose::Meta::TypeConstraint->new(
[23:00] 	stevan	            name       => $name || '__ANON__',
[23:00] 	stevan	            parent     => $parent,            
[23:00] 	stevan	            constraint => $check,       
[23:00] 	stevan	            message    => $message,    
[23:00] 	stevan	        );
[23:00] 	stevan	yeah thats kinda the long way
[23:00] 	stevan	mst: what would you like it to be?
[23:00] 	mst	$parent = find_type_constraint($parent) if defined $parent;
[23:00] 	mst	if $parent is already a type constraint
[23:00] 	mst	skip that bit
[23:00] 	stevan	hmm
[23:00] 	mst	should be all you need to change
[23:00] 	stevan	yeah
[23:01] 	stevan	so you can then say 
[23:01] 	stevan	subtype $anon => where { ... };
[23:01] 	mst	right
[23:01] 	stevan	ok

- method keyword

[23:37] 	mst	more seriously, I'd still like a "method" keyword or something
[23:37] 	mst	method 'foo' => sub { ... };
[23:38] 	stevan	what would it do more than sub foo { ... }?
[23:39] 	stevan	I would like multimethods actually
[23:39] 	mst	almost exactly nothing, to begin with
[23:39] 	stevan	but thats just cause I love CLOS and am reading a book on Dylan now
[23:40] 	stevan	keyword squating :)
[23:40] 	mst	but if we need to hook stuff later it's bloody handy to already have people writing it that way
[23:40] 	mst	right
...
[23:49] 	mst	oh, also: method 'has' => sub { ... } could squelch the redefine warning

- Role excludes

[17:00] 	stevan	I am reading the new Fortress Spec 
[17:00] 	stevan	http://research.sun.com/projects/plrg/fortress0903.pdf
[17:00] 	stevan	they have traits too
[17:01] 	stevan	and they have one cool feature which we might want to steal
[17:01] 	stevan	traits can "exclude" other traits
[17:01] 	stevan	which means they cannot be combined with other classes/roles which does() that trait
[17:01] 	stevan	the example they give is
[17:01] 	stevan	trait OrganicMolecule extends Molecule 
[17:01] 	stevan	    excludes { InorganicMolecule } 
[17:01] 	stevan	end 
[17:01] 	stevan	trait InorganicMolecule extends Molecule 
[17:01] 	stevan	end 
[17:01] 	stevan	this creates a set of mutually exclusive traits
[17:02] 	stevan	so that this:
[17:02] 	stevan	trait ScienceGoo extends { OrganicMolecule, InorganicMolocule } end
[17:02] 	stevan	would fail
[17:02] 	stevan	because OrganicMolecule, InorganicMolocule can never be used together
[17:03] 	stevan	I am thinking this is quite sane 
 
-------------------------------------------------------------------------------
TO PONDER
-------------------------------------------------------------------------------

- Moose "strict" mode

use Moose 'strict'; This would allow us to have all sort of expensive tests
which can be turned off in prod.     
        
- Moose::Philosophy.pod

To explain Moose from a very high level

- moosedoc

We certainly have enough meta-information to make pretty complete POD docs.