=head1 VERSION
-Version 0.03
+Version 0.04
=cut
our $VERSION;
BEGIN {
- $VERSION = '0.03';
+ $VERSION = '0.04';
}
=head1 SYNOPSIS
=back
-=back
+Note that if the type is a constant, C<$_[0]> will be set to the I<value> of constant and not to its name.
+
+ use Lexical::Types as => sub { $_[0] => 'new' };
+ use constant Str => 'MyStr';
+ my Str $x; # calls MyStr->new
-The initializer method receives an alias to the pad entry of C<$x> in C<$_[1]> and the original type name (C<Str>) in C<$_[2]>.
-You can either edit C<$_[1]> in place, in which case you should return an empty list, or return a new scalar that will be copied into C<$x>.
+This means in particular that you can't both use constant types and redirect several types to different methods of the same package, because then you can't distinguish between the original types with C<$_[0]>.
+
+=back
=cut
$^H{+(__PACKAGE__)} = undef;
}
+=head1 RUN-TIME INITIALIZER METHOD
+
+The initializer method receives an alias to the pad slot of the initialized lexical in C<$_[1]> and the original type name in C<$_[2]>.
+You can either edit C<$_[1]> in place, in which case you should return an empty list, or return a new scalar that will be copied into the pad slot.
+
+ use Lexical::Types as => 'My';
+
+ my Str $x;
+
+ ...
+
+ sub My::Str::TYPEDSCALAR {
+ # $_[1] is an alias to $x, and $_[2] is 'Str'
+ ...
+ }
+
=head1 INTEGRATION
You can integrate L<Lexical::Types> in your module so that using it will provide types to your users without asking them to load either L<Lexical::Types> or the type classes manually.
sub new_int { ... }
+If you prefer to use constants rather than creating empty packages, you can replace the previous example with something like this :
+
+ package MyTypes;
+
+ BEGIN { require Lexical::Types; }
+
+ sub import {
+ my $pkg = caller;
+ for (qw/Str Int/) {
+ my $type = __PACKAGE__ . '::' . $_;
+ no strict 'refs';
+ no warnings 'redefine';
+ *{$pkg.'::'.$_} = eval "sub () { '$type' }";
+ }
+ Lexical::Types->import(
+ as => sub { $_[0] => 'new' }
+ );
+ }
+
+ sub unimport {
+ Lexical::Types->unimport;
+ }
+
+ package MyTypes::Str;
+
+ sub new { ... }
+
+ package MyTypes::Int;
+
+ sub new { ... }
+
=head1 CAVEATS
For C<perl> to be able to parse C<my Str $x>, you need :