File Coverage

blib/lib/Sub/Become.pm

Criterion	Covered	Total	%
statement	21	21	100.0
branch	1	2	50.0
condition	1	3	33.3
subroutine	7	7	100.0
pod	1	1	100.0
total	31	34	91.1

package Sub::Become;

use warnings;
use strict;
use Carp;
use base qw( Exporter );

our @EXPORT_OK = our @EXPORT = qw( become );

=head1 NAME

Sub::Become - Syntactic sugar to allow a sub to replace itself

=head1 VERSION

This document describes Sub::Become version 0.01

=cut

our $VERSION = '0.01';

=head1 SYNOPSIS

    use Sub::Become;

    sub foo {
        my $t = Date->new();
        become {
            return $t;
        }
        return foo();
    }

=head1 DESCRIPTION

A useful technique in languages like JavaScript is to write a function
that replaces its own definition:

    var foo = function() {
        var t = new Date();
        foo = function() {
            return t;
        };
        return foo();
    };

See L for a complete explanation
of the technique.

C provides a little syntactic sugar to make this
easy in Perl too. See the SYNOPSIS for an example.

=head1 INTERFACE

=head2 C<< become >>

Replace the current subroutine with the supplied code block:

    sub bar {
        become { 2 }; # return 2 next time
        return 1;     # return 1 first time
    }

If you need to return the value that the new subroutine definition would
have returned in the same invocation either have the subroutine recurse:

    sub expensive {
        my $thing = some_expensive_calculation();
        become { $thing };
        return expensive();
    }

Or exploit the fact that C returns the code reference for the
new definition:

    sub expensive {
        my $thing = some_expensive_calculation();
        return (become { $thing })->();
    }

=cut

sub become(&) {
    croak "become needs a coderef"
      unless @_ == 1 && 'CODE' eq ref $_[0];
    no strict 'refs';
    no warnings 'redefine';
    return *{ ( caller 1 )[3] } = shift;
}

1;
__END__