89 lines
3.9 KiB
Org Mode
89 lines
3.9 KiB
Org Mode
# -*-org-*-
|
|
# TITLE: GNU ease.js Traits
|
|
|
|
The trait implementation is not yet complete; this is the list of known
|
|
issues/TODOs. If you discover any problems, please send an e-mail to
|
|
bug-easejs@gnu.org.
|
|
|
|
Aside from the issues below, traits are stable and ready to be used in
|
|
production. See the test cases and performance tests for more
|
|
information and a plethora of examples until the documentation is
|
|
complete.
|
|
|
|
|
|
* TODO Trait Extending
|
|
Currently, the only way for a trait to override methods of a class
|
|
it is being mixed into is to implement a common interface. Traits
|
|
should alternatively be able to "extend" classes, which will have
|
|
effects similar to Scala in that the trait can only be mixed into
|
|
that class. Further, traits should be able to extend and mix in
|
|
other traits (though such should be done conservatively).
|
|
|
|
* TODO Documentation
|
|
Due to the trait implementation taking longer than expected to
|
|
complete, and the importance of the first GNU release, trait
|
|
documentation is not yet complete. Instead, traits have been
|
|
released as a development preview, with the test cases and
|
|
performance tests serving as interim documentation.
|
|
|
|
Comprehensive documentation, including implementation details and
|
|
rationale, will be available shortly.
|
|
|
|
* TODO Static members
|
|
Static members are currently unsupported. There is no particular
|
|
difficulty in implementing them---the author didn't want it to hold
|
|
up an initial release (the first GNU release) even further.
|
|
|
|
* TODO Getters/setters
|
|
Getters and setters, although they act like properties, should be
|
|
treated as though they are methods. Further, they do not suffer
|
|
from the same complications as properties, because they are only
|
|
available in an ES5 environment (as an ECMAScript language feature).
|
|
|
|
* TODO Mixin Caching
|
|
The pattern =Type.use(...)(...)=---that is, mix a trait into a class
|
|
and immediate instantiate the result---is a common idiom that can
|
|
often be better for self-documentation than storing the resulting
|
|
class in another variable before instantiation. Currently, it's also
|
|
a terrible thing to do in any sort of loop, as it re-mixes each and
|
|
every time.
|
|
|
|
We should introduce a caching system to avoid that cost and make it
|
|
fairly cheap to use such an idiom. Further, this would permit the
|
|
Scala-like ability to use Type.use in Class.isA checks.
|
|
|
|
* TODO Public/Protected Property Support
|
|
Private properties are currently supported on traits because they do
|
|
not affect the API of the type they are mixed into. However, due to
|
|
limitations of pre-ES5 environments, implementing public and
|
|
protected member epoxying becomes ugly in the event of a fallback,
|
|
amounting essentially to re-assignment before/after trait method
|
|
proxying. It is possible, though.
|
|
|
|
This is not a necessary, or recommended, feature---one should aim to
|
|
encapsulate all data, not expose it---but it does have its
|
|
legitimate uses. As such, this is not a high-priority item.
|
|
|
|
* TODO Trait-specific error messages
|
|
All error messages resulting from traits should refer to the trait
|
|
by name and any problem members by name, and should offer
|
|
context-specific suggestions for resolution. Currently, the errors
|
|
may be more general and may reflect the internal construction of
|
|
traits, which will be rather confusing to users.
|
|
|
|
* TODO Performance enhancements
|
|
The current trait implementation works well, but is relatively slow
|
|
(compared to how performant it could be). While this is sufficient
|
|
for most users' uses, there is plenty of room for
|
|
improvement. Until that time, be mindful of the performance test
|
|
cases in the =test/perf= directory.
|
|
|
|
* TODO Intermediate object as class
|
|
The immediate syntax---=Foo.use(T)()=---is a short-hand equivalent
|
|
of =Foo.use(T).extend({})()=. As such, for consistency, =Class.isA=
|
|
should consider the intermediate object returned by a call to =use=
|
|
to be a class.
|
|
|
|
If we are to do so, though, we must make sure that the entire class
|
|
API is supported.
|