sub::defer(3) [osx man page]

Sub::Defer(3)						User Contributed Perl Documentation					     Sub::Defer(3)

NAME

       Sub::Defer - defer generation of subroutines until they are first called

SYNOPSIS

	use Sub::Defer;

	my $deferred = defer_sub 'Logger::time_since_first_log' => sub {
	   my $t = time;
	   sub { time - $t };
	};

	 Logger->time_since_first_log; # returns 0 and replaces itself
	 Logger->time_since_first_log; # returns time - $t

DESCRIPTION

       These subroutines provide the user with a convenient way to defer creation of subroutines and methods until they are first called.

SUBROUTINES

   defer_sub
	my $coderef = defer_sub $name => sub { ... };

       This subroutine returns a coderef that encapsulates the provided sub - when it is first called, the provided sub is called and is -itself-
       expected to return a subroutine which will be goto'ed to on subsequent calls.

       If a name is provided, this also installs the sub as that name - and when the subroutine is undeferred will re-install the final version
       for speed.

   undefer_sub
	my $coderef = undefer_sub &Foo::name;

       If the passed coderef has been deferred this will "undefer" it.	If the passed coderef has not been deferred, this will just return it.

       If this is confusing, take a look at the example in the "SYNOPSIS".

perl v5.16.2							    2012-07-04							     Sub::Defer(3)

Sub::Quote(3pm) 					User Contributed Perl Documentation					   Sub::Quote(3pm)

NAME

       Sub::Quote - efficient generation of subroutines via string eval

SYNOPSIS

	package Silly;

	use Sub::Quote qw(quote_sub unquote_sub quoted_from_sub);

	quote_sub 'Silly::kitty', q{ print "meow" };

	quote_sub 'Silly::doggy', q{ print "woof" };

	my $sound = 0;

	quote_sub 'Silly::dagron',
	  q{ print ++$sound % 2 ? 'burninate' : 'roar' },
	  { '$sound' => $sound };

       And elsewhere:

	Silly->kitty;  # meow
	Silly->doggy;  # woof
	Silly->dagron; # burninate
	Silly->dagron; # roar
	Silly->dagron; # burninate

DESCRIPTION

       This package provides performant ways to generate subroutines from strings.

SUBROUTINES

   quote_sub
	my $coderef = quote_sub 'Foo::bar', q{ print $x++ . "
" }, { '$x' =>  };

       Arguments: ?$name, $code, ?\%captures, ?\%options

       $name is the subroutine where the coderef will be installed.

       $code is a string that will be turned into code.

       "\%captures" is a hashref of variables that will be made available to the code.	See the "SYNOPSIS"'s "Silly::dagron" for an example using
       captures.

       options

       o no_install

	 Boolean.  Set this option to not install the generated coderef into the passed subroutine name on undefer.

   unquote_sub
	my $coderef = unquote_sub $sub;

       Forcibly replace subroutine with actual code.  Note that for performance reasons all quoted subs declared so far will be globally
       unquoted/parsed in a single eval. This means that if you have a syntax error in one of your quoted subs you may find out when some other
       sub is unquoted.

       If $sub is not a quoted sub, this is a no-op.

   quoted_from_sub
	my $data = quoted_from_sub $sub;

	my ($name, $code, $captures, $compiled_sub) = @$data;

       Returns original arguments to quote_sub, plus the compiled version if this sub has already been unquoted.

       Note that $sub can be either the original quoted version or the compiled version for convenience.

   inlinify
	my $prelude = capture_unroll {
	  '$x' => 1,
	  '$y' => 2,
	};

	my $inlined_code = inlinify q{
	  my ($x, $y) = @_;

	  print $x + $y . "
";
	}, '$x, $y', $prelude;

       Takes a string of code, a string of arguments, a string of code which acts as a "prelude", and a Boolean representing whether or not to
       localize the arguments.

   capture_unroll
	my $prelude = capture_unroll {
	  '$x' => 1,
	  '$y' => 2,
	};

       Generates a snippet of code which is suitable to be used as a prelude for "inlinify".  The keys are the names of the variables and the
       values are (duh) the values.  Note that references work as values.

CAVEATS

       Much of this is just string-based code-generation, and as a result, a few caveats apply.

   return
       Calling "return" from a quote_sub'ed sub will not likely do what you intend.  Instead of returning from the code you defined in
       "quote_sub", it will return from the overall function it is composited into.

       So when you pass in:

	  quote_sub q{	return 1 if $condition; $morecode }

       It might turn up in the intended context as follows:

	 sub foo {

	   <important code a>
	   do {
	     return 1 if $condition;
	     $morecode
	   };
	   <important code b>

	 }

       Which will obviously return from foo, when all you meant to do was return from the code context in quote_sub and proceed with running
       important code b.

perl v5.14.2							    2012-06-26							   Sub::Quote(3pm)