++ed by:
Toby Inkster

NAME

returning - define subs that act like return

SYNOPSIS

        use Test::Simple tests => 1;
        
        use returning {
                Yes   => 1,
                No    => 0,
        };
        
        sub beats_sissors
        {
                local $_ = shift;
                No  if /paper/i;
                Yes if /rock/i;
                No  if /scissors/;
        }
        
        ok beats_scissors("rock");

DESCRIPTION

The returning module allows you to define subs which act like return. That is, they break out of their caller sub. In the SYNPOSIS example, the /scissors/i regexp is never even evaluated because the Yes statement breaks out of the the sub, returning "1". The beats_scissors function could have alternatively been written as:

        sub beats_sissors
        {
                local $_ = shift;
                return 0 if /paper/i;
                return 1 if /rock/i;
                return 0 if /scissors/;
        }

returning may be especially useful for domain-specific languages.

Usage

There are three ways to define a returning sub using this module:

        use returning { subname => 'value' };

This creates the sub in the caller's namespace called subname with an empty prototype. (So when calling the sub, you don't need to use parentheses; just like with constant subs, but without as much optimization.)

        use returning { subname => sub { ... } }

This installs the provided sub into the caller's namespace. This allows you to define non-constant subs, including subs that take parameters and do interesting stuff with them.

        BEGIN {
                sub subname { ... }
        };
        use returning 'subname'; # look, no hashref!

This does not install any sub into the caller's namespace, but modifies an existing sub to act in a returning way. Note that because use operates at compile time, you need to take a lot of care to ensure that the sub has already been defined.

These can be combined, a la...

        use constant ZeroButTrue => '0E0';
        use returning 'ZeroButTrue', {
                Affirm   => !!1,
                Deny     => !!0,
                Mu       => sub { return; },
        }

Implementation Notes

My first stab at this used Devel::Declare, but I couldn't quite get it working, and nobody in #devel-declare seemed sure why it was not. It seems possible that the ability to do this lies slightly beyond what Devel::Declare is capable of.

Instead Scope::Upper has been used to create wrappers which jump up one more subroutine than expected when they return. This means that some of the magic happens at run-time rather than compile-time, so it perhaps executes slightly slower, but probably compiled slightly faster.

An advantage of Scope::Upper is that you can re-export your returning subs to other packages with no problem, and they'll continue to have their special behaviour with no extra effort.

A feature I had been hoping to achieve with Devel::Declare would be for calling a sub with an ampersand (&Affirm()) to act as a way of avoiding the magic behaviour. This has not been possible with Scope::Upper.

Class Method

returning->setup_for($package, $subname)

Given the package name and subname of an existing sub, sets up the magic.

BUGS

Please report any bugs to http://rt.cpan.org/Dist/Display.html?Queue=returning.

SEE ALSO

Scope::Upper takes care of most of the black magic.

AUTHOR

Toby Inkster <tobyink@cpan.org>.

CREDITS

Thanks OSFAMERON, Matt S Trout (MSTROUT), and Ash Berlin (ASH), for helping me through some of the tricky bits.

COPYRIGHT AND LICENCE

This software is copyright (c) 2012 by Toby Inkster.

This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.

DISCLAIMER OF WARRANTIES

THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.




Hosting generously
sponsored by Bytemark