| Name : perl-Class-SelfMethods
| |
| Version : 1.08
| Vendor : obs://build_opensuse_org/devel:languages:perl
|
| Release : 8.70
| Date : 2024-08-05 19:20:49
|
| Group : Development/Libraries/Perl
| Source RPM : perl-Class-SelfMethods-1.08-8.70.src.rpm
|
| Size : 0.03 MB
| |
| Packager : (none)
| |
| Summary : Module for supporting instance-defined methods
|
Description :
Development of this module has largely lapsed due to the superior
performance and feature set of \'Class::Prototyped\'. If you haven\'t written
code that depends upon \'Class::SelfMethods\', I strongly urge you to look at
\'Class::Prototyped\' first.
\'Class::SelfMethods\' merges some features of other Object Oriented
languages to build a system for implementing more flexible objects than is
provided by default in Perl.
The core features I was looking for when I wrote \'Class::SelfMethods\' were:
* Class-based inheritance hierarchy
I wanted to retain Perl\'s normal class-based inheritance hierarchy rather
than to write (or use) a completely prototype based system. If you are
looking for a purely prototype based system, see Sean M. Burke\'s
\'Class::Classless\'. My reasoning on this is that it is easier in file based
languages (as opposed to world based languages like Self) to code class
based inheritance hierarchies (which are largely static) than to code
object based inheritance hierarchies (since objects in such languages have
a dynamicism that is not granted to classes).
* Instance-defined method overriding
I wanted instances to be able to override their class-defined methods. In
the example above, the \'$bas\' object has its own \'friendly\' method.
Instance-defined methods are passed the exact same parameter list as
class-defined methods.
* Subroutine/Attribute equivalence
Borrowing from Self, I wanted to be able to treat methods and attributes
similarly. For instance, in the above example the \'$bar\' object has an
attribute \'friendly\', whereas the \'$bas\' object has a method \'friendly\',
and the \'$foo\' object uses the class-defined method. The calling syntax is
independent of the implementation. Parameters can even be passed in the
method call and they will simply be ignored if the method is implemented by
a simple attribute
In addition to those core features, I (and Damian) had a wish list of
additional features:
* Simple syntax
I wanted the system to be reasonable easy to use for both implementers of
classes and users of objects. Simple syntax for users is more important
than simple syntax for implementers.
* Full support for \'SUPER\' type concepts
I wanted instance-defined methods to be able to call the class-defined
methods they replace.
* Support for calling methods at instantiation time
In some circumstances, rather than deal with multiple inheritance it is
easier to have a class-defined object method that sets up the various
instance-defined methods for a given object. To support this, the \'new\'
method allows deferred method calls to be passed in as parameters.
* Modifying objects post-instantiation
I originally had no need for modifying objects post-instantiation, but
Damian Conway thought it would be a Good Thing (TM) to support. Being so
very good at these sorts of thing, he instantly came up with a good general
syntax to support such. Method calls that end in a \'_SET\' result in the
first parameter being assigned to the attribute/method. I noticed one
remaining hole and added support for \'_CLEAR\'.
|
RPM found in directory: /packages/linux-pbone/ftp5.gwdg.de/pub/opensuse/repositories/devel:/languages:/perl:/CPAN-C/openSUSE_Tumbleweed/noarch |
