+ "unwind @values, $context"
+ Returns @values *from* the context pointed by $context, i.e. from the
+ subroutine, eval or format at or just above $context, and immediately
+ restart the program flow at this point - thus effectively returning to
+ an upper scope.
+
+ The upper context isn't coerced onto @values, which is hence always
+ evaluated in list context. This means that
+
+ my $num = sub {
+ my @a = ('a' .. 'z');
+ unwind @a => HERE;
+ # not reached
+ }->();
+
+ will set $num to 'z'. You can use "want_at" to handle these cases.
+
+ "want_at $context"
+ Like "wantarray", but for the subroutine/eval/format at or just above
+ $context.
+
+ The previous example can then be "corrected" :
+
+ my $num = sub {
+ my @a = ('a' .. 'z');
+ unwind +(want_at(HERE) ? @a : scalar @a) => HERE;
+ # not reached
+ }->();
+
+ will rightfully set $num to 26.
+
+ "uplevel $code, @args, $context"
+ Executes the code reference $code with arguments @args as if it were
+ located at the subroutine stack frame pointed by $context, effectively
+ fooling "caller" and "die" into believing that the call actually
+ happened higher in the stack. The code is executed in the context of the
+ "uplevel" call, and what it returns is returned as-is by "uplevel".
+
+ sub target {
+ faker(@_);
+ }
+
+ sub faker {
+ uplevel {
+ map { 1 / $_ } @_;
+ } @_ => CALLER(1);
+ }
+
+ my @inverses = target(1, 2, 4); # @inverses contains (0, 0.5, 0.25)
+ my $count = target(1, 2, 4); # $target is 3
+
+ Sub::Uplevel also implements a pure-Perl version of "uplevel". Both are
+ identical, with the following caveats :
+
+ * The Sub::Uplevel implementation of "uplevel" may execute a code
+ reference in the context of any upper stack frame. The Scope::Upper
+ version only allows to uplevel to a subroutine stack frame, and will
+ croak if you try to target an "eval" or a format.
+
+ * Exceptions thrown from the code called by this version of "uplevel"
+ will not be caught by "eval" blocks between the target frame and the
+ uplevel call, while they will for Sub::Uplevel's version. This means
+ that :
+
+ eval {
+ sub {
+ local $@;
+ eval {
+ sub {
+ uplevel { die 'wut' } CALLER(2); # for Scope::Upper
+ # uplevel(3, sub { die 'wut' }) # for Sub::Uplevel
+ }->();
+ };
+ print "inner block: $@";
+ $@ and exit;
+ }->();
+ };
+ print "outer block: $@";
+
+ will print "inner block: wut..." with Sub::Uplevel and "outer block:
+ wut..." with Scope::Upper.
+
+ * Sub::Uplevel globally overrides "CORE::GLOBAL::caller", while
+ Scope::Upper does not.
+
+ A simple wrapper lets you mimic the interface of "uplevel" in
+ Sub::Uplevel :
+
+ use Scope::Upper;
+
+ sub uplevel {
+ my $frame = shift;
+ my $code = shift;
+ my $cxt = Scope::Upper::CALLER($frame);
+ &Scope::Upper::uplevel($code => @_ => $cxt);
+ }
+
+ Albeit the three exceptions listed above, it passes all the tests of
+ Sub::Uplevel.
+
+CONSTANTS
+ "SU_THREADSAFE"
+ True iff the module could have been built when thread-safety features.
+
+WORDS
+ Constants
+ "TOP"
+ Returns the context that currently represents the highest scope.
+
+ "HERE"
+ The context of the current scope.
+
+ Getting a context from a context
+ For any of those functions, $from is expected to be a context. When
+ omitted, it defaults to the the current context.
+
+ "UP $from"
+ The context of the scope just above $from.
+
+ "SUB $from"
+ The context of the closest subroutine above $from. Note that $from is
+ returned if it is already a subroutine context ; hence "SUB SUB == SUB".
+
+ "EVAL $from"
+ The context of the closest eval above $from. Note that $from is returned
+ if it is already an eval context ; hence "EVAL EVAL == EVAL".
+
+ Getting a context from a level
+ Here, $level should denote a number of scopes above the current one.
+ When omitted, it defaults to 0 and those functions return the same
+ context as "HERE".
+
+ "SCOPE $level"
+ The $level-th upper context, regardless of its type.
+
+ "CALLER $level"
+ The context of the $level-th upper subroutine/eval/format. It kind of
+ corresponds to the context represented by "caller $level", but while
+ e.g. "caller 0" refers to the caller context, "CALLER 0" will refer to
+ the top scope in the current context.
+
+ Examples
+ Where "reap" fires depending on the $cxt :
+
+ sub {
+ eval {
+ sub {
+ {
+ reap \&cleanup => $cxt;
+ ...
+ } # $cxt = SCOPE(0), or HERE
+ ...
+ }->(); # $cxt = SCOPE(1), or UP, or SUB, or CALLER, or CALLER(0)
+ ...
+ }; # $cxt = SCOPE(2), or UP UP, or UP SUB, or EVAL, or CALLER(1)
+ ...
+ }->(); # $cxt = SCOPE(3), or SUB UP SUB, or SUB EVAL, or CALLER(2)
+ ...
+
+ Where "localize", "localize_elem" and "localize_delete" act depending on
+ the $cxt :
+
+ sub {
+ eval {
+ sub {
+ {
+ localize '$x' => 1 => $cxt;
+ # $cxt = SCOPE(0), or HERE
+ ...
+ }
+ # $cxt = SCOPE(1), or UP, or SUB, or CALLER, or CALLER(0)
+ ...
+ }->();
+ # $cxt = SCOPE(2), or UP UP, or UP SUB, or EVAL, or CALLER(1)
+ ...
+ };
+ # $cxt = SCOPE(3), or SUB UP SUB, or SUB EVAL, or CALLER(2)
+ ...
+ }->();
+ # $cxt = SCOPE(4), UP SUB UP SUB, or UP SUB EVAL, or UP CALLER(2), or TOP
+ ...
+
+ Where "unwind", "want_at" and "uplevel" point to depending on the $cxt:
+
+ sub {
+ eval {
+ sub {
+ {
+ unwind @things => $cxt; # or uplevel { ... } $cxt;
+ ...
+ }
+ ...
+ }->(); # $cxt = SCOPE(0 .. 1), or HERE, or UP, or SUB, or CALLER(0)
+ ...
+ }; # $cxt = SCOPE(2), or UP UP, or UP SUB, or EVAL, or CALLER(1) (*)
+ ...
+ }->(); # $cxt = SCOPE(3), or SUB UP SUB, or SUB EVAL, or CALLER(2)
+ ...
+
+ # (*) Note that uplevel() will croak if you pass that scope frame,
+ # because it can't target eval scopes.