[svn:parrot-pdd] r15024 - trunk/docs/pdds/clip
jona...@cvs.perl.org
Date: Wed Oct 25 15:29:31 2006
New Revision: 15024
Modified:
trunk/docs/pdds/clip/pdd15_objects.pod
Log:
Add REQUIREMENTS section to PDD15 Objects, to enable us to start fleshing out what Parrot's object system needs to do. Includes hopefully most of what Perl 6 and .Net need as a starting point.
Modified: trunk/docs/pdds/clip/pdd15_objects.pod
==============================================================================
--- trunk/docs/pdds/clip/pdd15_objects.pod (original)
+++ trunk/docs/pdds/clip/pdd15_objects.pod Wed Oct 25 15:29:31 2006
@@ -5,6 +5,99 @@
docs/pdds/pdd15_objects.pod - Object and Class semantics for Parrot
+=head1 REQUIREMENTS
+This PDD is due an overhaul. This requirements section is for language
+implementers to list the OO-related needs of their language in so as to aid
+that.
+
+=head2 Classes
+A class is a collection of methods and attributes. It would be desirable, for
+those classes whose definition is fully known at compile time, to have a
+convenient way to have the class along with its attributes and methods stored
+into a PBC file rather than created at runtime. However, creation of new
+classes at runtime will be needed too.
+
+=head2 Attributes
+Attributes are instance data associated with a class (or role, however those
+are supported). They may not always be of a type specified by a PMC, though
+boxing/unboxing is of course an option.
+
+Perl 6: All attributes are opaque (not externally visible, even to any
+subclasses).
+
+.Net: Attributes may be private (not externally visible), public (always
+externally visible), protected (only visible to subclasses) and internal
+(only visible inside the current assembly - the closest correspondnece in
+Parrot is perhaps only visible inside the same PBC file). Additionally, it
+is allowable for a subclass to introduce an attribute of the same name as
+the a parent class has, and they both exist depending on what type an
+instance of the class is currently viewed as being (read: there is a
+difference between the type of the reference and the type of the value).
+
+=head2 Methods
+Perl 6: Methods may be public (anyone can invoke them) or private (only
+invokable by the class they are defined in). Additionally, submethods are
+methods that do not get inherited.
+
+.Net: Like attributes, methods may be public, private, protected or internal.
+
+=head2 Inheritance
+Perl 6: Multiple inheritance.
+
+.Net: Single inheritance.
+
+=head2 Interfaces
+An interface specifies a set of methods that must be implemented by a class
+that inherits (or implements) the interface, but does not provide any form of
+implementation for them.
+
+.Net: Interfaces are pretty much what was just describe above. XXX Need to
+check behaviour of you implement two interfaces with methods of the same name.
+
+=head2 Roles
+A role consists of a set of methods and attributes. It cannot be instantiated
+on its own, but must be composed into a class. When this happens its methods
+and attributes become of that classes methods and attributes. This may happen
+at compile time or runtime, however when a role is composed into a class at
+runtime then what really happens is that a new anonymous class is created with
+the role composed into it and then the namespace entry for the existing class is
+updated to refer to the new one. Note that this means classes must be garbage
+collectable, with all those referred to by a namespace or with objects of that
+class existing being marked live.
+
+Perl 6: Roles pretty much are a Perl 6 thing, so the definition above contains
+all that is needed. An open question is whether Parrot worry about collision
+detection? For compile time composition that's easy to punt to the compiler;
+for runtime composition, that's not so easy though.
+
+=head2 Introspection (aka Reflection)
+Perl 6: Reflection provides access to a list of methods that a class has, its
+parent classes and the roles it does, as well as the name of the class and its
+memory address. For methods, their name, signature, return type and whether
+the method is declared multi are available.
+
+.Net: Reflection provides access to a list of attributes and methods as well as
+the name of the class and its parent. The types of attributes and signatures of
+methods are also available.
+
+=head2 Inner Classes
+An inner class is essentially a class defined within a class. Therefore it has
+access to things private to its outer class.
+
+Perl 6: Inner classes are allowed, and may also be private.
+
+.Net: Inner classes are allowed and may be private, public, protected or
+internal.
+
+=head2 Delegation
+Delegation is where a method call is "forwarded" to another class. Parrot may
+provide support for simple cases of it directly, or could just provide a "no
+method matched" fallback method that the compiler fills out to implement the
+delegation.
+
+Perl 6: Delegation support is highly flexible, even allowing a regex to match
+method names that should be delegated to a particular object.
+
=head1 ABSTRACT
This PDD describes the semantics of Parrot's object and class systems. The PDD