stop closing over the method metaobject
[gitmo/Moose.git] / TODO
1 == Todo for 2.0200
2
3 === Revise MetaRole API to reunify class/role metaroles:
4
5   apply_metaroles(
6       for   => $meta,
7       roles => {
8           attribute => [...],
9           class     => [...],
10           role_attribute => [ ... ],
11       }
12   );
13
14 If the $meta is a class, we apply the roles to the class. If it's a role, we
15 hold onto them and apply them as part of applying the role to a class.
16
17 To make this all work nicely, we'll probably want to track the original role
18 where a method was defined, just like we do with attributes currently. We'll
19 also need to store method modifiers with their original role, which may mean
20 adding some sort of Moose::Meta::Role::MethodModifier class.
21
22 For each role-specific thing (methods, attributes, etc.) we should allow a
23 role_attribute, role_method, etc. key. The common case will be that the
24 metaroles are intended for the consuming class, but we should allow for
25 metaroles on the role's metaobjects as well.
26
27 === Remove a bunch of deprecated crap
28
29 See Moose::Manual::Delta for a list. Some of this is important to make merging
30 Class::MOP into Moose core much easier. Other is just removing complexity
31 needed to support ancient APIs.
32
33 == Old todo (does anyone look at this?)
34
35 -------------------------------------------------------------------------------
36 BUGS
37 -------------------------------------------------------------------------------
38
39 -------------------------------------------------------------------------------
40 FEATURES
41 -------------------------------------------------------------------------------
42
43 - DDuncan's Str types
44
45 subtype 'Str'
46     => as 'Value'
47     => where { Encode::is_utf8( $_[0] ) or $_[0] !~ m/[^0x00-0x7F]/x }
48     => optimize_as { defined($_[0]) && !ref($_[0]) };
49
50 subtype 'Blob'
51     => as 'Value'
52     => where { !Encode::is_utf8( $_[0] ) }
53     => optimize_as { defined($_[0]) && !ref($_[0]) };
54
55 - type unions
56
57 Add support for doing it with Classes which do not have
58 a type constraint yet created
59
60 - type intersections
61
62 Mostly just for Roles
63
64 - inherited slot specs
65
66 'does' can be added to,.. but not changed
67 (need type unions for this)
68
69 - proxy attributes
70
71 a proxied attribute is an attribute
72 which looks like an attribute,
73 talks like an attribute, smells
74 like an attribute,.. but if you
75 look behind the curtain,.. its
76 over there.. in that other object
77
78 (... probably be a custom metaclass)
79
80 - local coerce
81
82 [13:16]         mst     stevan: slight problem with coerce
83 [13:16]         mst     I only get to declare it once
84 [13:17]         mst     so if I'm trying to declare it cast-style per-source-class rather than per-target-class
85 [13:17]         mst     I am extremely screwed
86 [13:17]         stevan  yes
87 [13:17]         stevan  they are not class specific
88 [13:18]         stevan  they are attached to the type constraint itself
89 [13:18]         *       stevan ponders anon-coercion-metaobjects
90 [13:18]         mst     yes, that's fine
91 [13:19]         mst     but when I declare a class
92 [13:19]         mst     I want to be able to say "this class coerces to X type via <this>"
93 [13:19]         stevan  yeah something like that
94 [13:19]         stevan  oh,.. hmm
95 [13:20]         stevan  sort of like inflate/deflate?
96 [13:20]         stevan  around the accessors?
97 [13:25]         *       bluefeet has quit (Remote host closed the connection)
98 [13:27]         mst     no
99 [13:27]         mst     nothing like that
100 [13:27]         mst     like a cast
101 [13:31]         mst     stevan: $obj->foo($bar); where 'foo' expects a 'Foo' object
102 [13:31]         mst     stevan: is effectively <Foo>$bar, right?
103 [13:32]         mst     stevan: I want to be able to say in package Bar
104 [13:32]         mst     stevan: coerce_to 'Foo' via { ... };
105 [13:32]         mst     etc.
106 [13:53]         stevan  hmm
107
108 -----------------------------------------------------------
109 -- Type Constraints refactor
110 -----------------------------------------------------------
111
112 - add support for locally scoped TC
113
114 This would borrow from MooseX::TypeLibrary to prefix the TC with the name
115 of the package. It would then be accesible from the outside as the fully
116 scoped name, but the local attributes would use it first. (this would need support
117 in the registry for this).
118
119 - look into sugar extensions
120
121 Use roles as sugar layer function providers (ala MooseX::AttributeHelpers). This
122 would allow custom metaclasses to provide roles to extend the sugar syntax with.
123
124 (NOTE: Talk to phaylon a bit more on this)
125
126 - allow a switch of some kind to optionally turn TC checking off at runtime
127
128 The type checks can get expensive and some people have suggested that allowing
129 the checks to be turned off would be helpful for deploying into performance
130 intensive systems. Perhaps this can actually be done as an option to make_immutable?
131
132 - misc. minor bits
133
134 * make the errors for TCs use ->message
135 * look into localizing the messages too
136 * make ANON TCs be lazy, so they can possibly be subsituted for the real thing later
137 * make ANON TCs more introspectable
138 * add this ...
139
140 #
141 #   Type Definition
142 #
143 subtype 'Username',
144    from 'Str',
145   where {     (/[a-z][a-z0-9]+/i or fail('Invalid character(s)'))
146           and (length($_) >= 5   or fail('Too short (less than 5 chars)'))
147         }
148 on_fail { MyException->throw(value => $_[0], message => $_[1]) };
149
150 # fail() will just return false unless the call is made via
151 $tc->check_or_fail($value);
152
153 * and then something like this:
154
155 subtype Foo => as Bar => where { ... } => scoped => -global;
156 subtype Foo => as Bar => where { ... } => scoped => -local;
157
158 # or
159
160 subtype Foo => as Bar => where { ... } => in __PACKAGE__ ;
161
162 # or (not sure if it would be possible)
163
164 my $Foo = subtype Bar => where { ... };
165
166 # ----------
167
168 [17:10]  <autarch> stevan: it should do it if I pass coerce => 1 as part of the attribute definition
169 [17:12]  <stevan> autarch: what I am not 100% sure of is how to tell it to deep coerce and when to not
170 [17:13]  <stevan> cause a basic coerce is from A to B
171 [17:13]  <autarch> hmm
172 [17:13]  <stevan> which is valid for collection types too
173 [17:13]  <stevan> deep coercion is what you are asking for
174 [17:13]  <autarch> yeah
175 [17:13]  <stevan> so perhaps we add deep_coerce => 1
176 [17:13]  <stevan> which will do it
177 [17:13]  <autarch> that's fine for me
178 [17:13]  <stevan> k
179
180 coerce_deeply => 1 # reads better
181
182 -------------------------------------------------------------------------------
183 INTERNALS
184 -------------------------------------------------------------------------------
185
186 - rationalize all the get_X methods for classes (and roles)
187
188 We have get_attribute, get_attributes_list, get_all_attributes,
189 etc. First, we need to make the method names consistent. If something
190 returns an attribute vs a name, that needs to be clear from the method
191 name. We also need to make sure that local vs. "entire inheritance
192 chain" is clear from the name.
193
194 This is mostly a CMOP change.
195
196 - Metaclass constructors
197
198 There's a _lot_ of different conventions in here. Some things to consider:
199
200 * new vs _new
201 * allowing new( 'name', %args ) vs ( name => 'name', %args )
202 * Method->wrap vs Method->new
203
204 - Moose::Meta::TypeConstraint::Parameter{izable,ized}
205
206 The relationship between these two classes is very odd. In particular,
207 this line in Parameterized is insane:
208
209     foreach my $type (Moose::Util::TypeConstraints::get_all_parameterizable_types()) {
210
211 Why does it need to loop through all parameterizable types? Shouldn't
212 it know which parameterizable type it "came from"?
213
214 - Moose::Util::TypeConstraints vs Moose::Meta::Type{Coercion,Constraint}
215
216 The Util module has _way_ too much functionality. It needs to be
217 refactored so it's a thin sugar layer on top of the meta API. As it
218 stands now, it does things like parse type names (and determine if
219 they're valid), manage the registry, and much more.
220
221 - Anything with a _(meta)?class method
222
223 Every method that returns a class name needs to become a rw attribute
224 that can be set via the constructor.
225
226 - The Moose::Error stuff
227
228 This is sort of half-implemented. We still use Carp directly, and the
229 internals can't decide how to throw an error (is it
230 Moose->throw_error, __PACKAGE__->throw_error, what?).
231
232 The internals need to be made consistent before we expose this to the
233 rest of the world.
234
235 -------------------------------------------------------------------------------
236 TO PONDER
237 -------------------------------------------------------------------------------
238
239 - Moose "strict" mode
240
241 use Moose 'strict'; This would allow us to have all sort of expensive tests
242 which can be turned off in prod.
243
244 - Moose::Philosophy.pod
245
246 To explain Moose from a very high level
247
248 - moosedoc
249
250 We certainly have enough meta-information to make pretty complete POD docs.
251
252
253