typesafety version 0.04
=======================
typesafety.pm - compile-time type usage static analysis
In other words, perform heuristics on your program before it is run, with a goal
of insuring that object oriented types are used consistently - the correct class
(or a subclass of it) is returned in the right places, provided in method call
argument lists in the right places, only assigned to the right variables, and
so on.
This software is beta! Critical things seem to work, but it needs more testing
(for bugs and usability) from the public before I can call it "1.0". The API
is subject to change (and has already changed with each version so far).
SYNOPSIS:
package main;
use typesafety; # 'summary', 'debug';
my FooBar $foo; # establish type-checked variables
my FooBar $bar; # FooBar is the base class of references $bar will hold
my BazQux $baz;
$foo = new FooBar; # this is okey, because $foo holds FooBars
$bar = $foo; # this is okey, because $bar also holds FooBars
# $foo = 10; # this would throw an error - 10 is not a FooBar
# $baz = $foo; # not allowed - FooBar isn't a BazQux
$foo = $baz; # is allowed - BazQux is a FooBar because of inheritance
$bar = $foo->foo($baz, 1); # this is okey, as FooBar::foo() returns FooBars also
typesafety::check(); # perform type check static analysis
#
package FooBar;
use typesafety;
# unneeded - new() defaults to prototype to return same type as package
# proto 'new', returns => 'FooBar';
sub new {
bless [], $_[0];
# or: bless whatever, __PACKAGE__;
# or: bless whatever, 'FooBar';
# or: my $type = shift; bless whatever, $type;
# or: my $type = shift; $type = ref $type if ref $type; bless whatever, $type;
}
sub foo (FooBar; BazQux, undef) { my $me = shift; return $me->new(); }
# or: proto 'foo', returns => 'FooBar'; sub foo { my $me = shift; return $me->new(); }
#
package BazQux;
use typesafety;
@ISA = 'FooBar';
DESCRIPTION:
Prevents you from mistakenly bathing cats.
Failure to keep track what kind of data is in a given variable or returned
from a given method is an epic source of confusion and frustration during
debugging.
Given a ->get_pet() method, you might try to bathe the output. If it always
a dog during testing, everything is fine, but sooner or later, you're
going to get a cat, and that can be rather bloody.
Welcome to Type Safety. Type Safety means knowing what kind of data you
have (atleast in general - it may be a subclass of the type you know
you have). Because you always know what kind of data it is, you see in
advance when you try to use something too generic (like a pet) where you
want something more specific (like a dog, or atleast a pet that implements
the "washable" interface).
Think of Type Safety as a new kind of variable scoping -
instead of scoping where the variables can be seen from, you're scoping
what kind of data they might contain.
INSTALLATION
To install this module type the following:
perl Makefile.PL
make
make test
make install
DEPENDENCIES
This module requires these other modules and libraries:
B::Generate
COPYRIGHT AND LICENCE
Distribute under the same terms as Perl itself.
Copyright (C) 2003 Scott Walters, scott@slowass.net