functions much like C<use integer;> You'd like this code
use MyMaths;
-
+
my $l = MyMaths->new(1.2);
my $r = MyMaths->new(3.4);
-
+
print "A: ", $l + $r, "\n";
-
+
use myint;
print "B: ", $l + $r, "\n";
-
+
{
no myint;
print "C: ", $l + $r, "\n";
}
-
+
print "D: ", $l + $r, "\n";
-
+
no myint;
print "E: ", $l + $r, "\n";
$$l + $$r;
}
};
-
+
sub new {
my ($class, $value) = @_;
bless \$value, $class;
}
-
+
1;
Note how we load the user pragma C<myint> with an empty list C<()> to
The interaction with the Perl compilation happens inside package C<myint>:
package myint;
-
+
use strict;
use warnings;
-
+
sub import {
- $^H{myint} = 1;
+ $^H{"myint/in_effect"} = 1;
}
-
+
sub unimport {
- $^H{myint} = 0;
+ $^H{"myint/in_effect"} = 0;
}
-
+
sub in_effect {
my $level = shift // 0;
my $hinthash = (caller($level))[10];
- return $hinthash->{myint};
+ return $hinthash->{"myint/in_effect"};
}
-
+
1;
As pragmata are implemented as modules, like any other module, C<use myint;>
User pragmata store their state by writing to the magical hash C<%^H>,
hence these two routines manipulate it. The state information in C<%^H> is
-stored in the optree, and can be retrieved at runtime with C<caller()>, at
-index 10 of the list of returned results. In the example pragma, retrieval
+stored in the optree, and can be retrieved read-only at runtime with C<caller()>,
+at index 10 of the list of returned results. In the example pragma, retrieval
is encapsulated into the routine C<in_effect()>, which takes as parameter
the number of call frames to go up to find the value of the pragma in the
user's script. This uses C<caller()> to determine the value of
-C<$^H{myint}> when each line of the user's script was called, and
+C<$^H{"myint/in_effect"}> when each line of the user's script was called, and
therefore provide the correct semantics in the subroutine implementing the
overloaded addition.
+=head1 Key naming
+
+There is only a single C<%^H>, but arbitrarily many modules that want
+to use its scoping semantics. To avoid stepping on each other's toes,
+they need to be sure to use different keys in the hash. It is therefore
+conventional for a module to use only keys that begin with the module's
+name (the name of its main package) and a "/" character. After this
+module-identifying prefix, the rest of the key is entirely up to the
+module: it may include any characters whatsoever. For example, a module
+C<Foo::Bar> should use keys such as C<Foo::Bar/baz> and C<Foo::Bar/$%/_!>.
+Modules following this convention all play nicely with each other.
+
+The Perl core uses a handful of keys in C<%^H> which do not follow this
+convention, because they predate it. Keys that follow the convention
+won't conflict with the core's historical keys.
+
=head1 Implementation details
The optree is shared between threads. This means there is a possibility that