STLExtract 1.0.0

data/Slic3r/Linux/lib/std/constant.pm

@@ -0,0 +1,397 @@
+package constant;
+use 5.005;
+use strict;
+use warnings::register;
+
+use vars qw($VERSION %declared);
+$VERSION = '1.21';
+
+#=======================================================================
+
+# Some names are evil choices.
+my %keywords = map +($_, 1), qw{ BEGIN INIT CHECK END DESTROY AUTOLOAD };
+$keywords{UNITCHECK}++ if $] > 5.009;
+
+my %forced_into_main = map +($_, 1),
+    qw{ STDIN STDOUT STDERR ARGV ARGVOUT ENV INC SIG };
+
+my %forbidden = (%keywords, %forced_into_main);
+
+my $str_end = $] >= 5.006 ? "\\z" : "\\Z";
+my $normal_constant_name = qr/^_?[^\W_0-9]\w*$str_end/;
+my $tolerable = qr/^[A-Za-z_]\w*$str_end/;
+my $boolean = qr/^[01]?$str_end/;
+
+BEGIN {
+    # We'd like to do use constant _CAN_PCS => $] > 5.009002
+    # but that's a bit tricky before we load the constant module :-)
+    # By doing this, we save 1 run time check for *every* call to import.
+    no strict 'refs';
+    my $const = $] > 5.009002;
+    *_CAN_PCS = sub () {$const};
+}
+
+#=======================================================================
+# import() - import symbols into user's namespace
+#
+# What we actually do is define a function in the caller's namespace
+# which returns the value. The function we create will normally
+# be inlined as a constant, thereby avoiding further sub calling 
+# overhead.
+#=======================================================================
+sub import {
+    my $class = shift;
+    return unless @_;			# Ignore 'use constant;'
+    my $constants;
+    my $multiple  = ref $_[0];
+    my $pkg = caller;
+    my $flush_mro;
+    my $symtab;
+
+    if (_CAN_PCS) {
+	no strict 'refs';
+	$symtab = \%{$pkg . '::'};
+    };
+
+    if ( $multiple ) {
+	if (ref $_[0] ne 'HASH') {
+	    require Carp;
+	    Carp::croak("Invalid reference type '".ref(shift)."' not 'HASH'");
+	}
+	$constants = shift;
+    } else {
+	unless (defined $_[0]) {
+	    require Carp;
+	    Carp::croak("Can't use undef as constant name");
+	}
+	$constants->{+shift} = undef;
+    }
+
+    foreach my $name ( keys %$constants ) {
+	# Normal constant name
+	if ($name =~ $normal_constant_name and !$forbidden{$name}) {
+	    # Everything is okay
+
+	# Name forced into main, but we're not in main. Fatal.
+	} elsif ($forced_into_main{$name} and $pkg ne 'main') {
+	    require Carp;
+	    Carp::croak("Constant name '$name' is forced into main::");
+
+	# Starts with double underscore. Fatal.
+	} elsif ($name =~ /^__/) {
+	    require Carp;
+	    Carp::croak("Constant name '$name' begins with '__'");
+
+	# Maybe the name is tolerable
+	} elsif ($name =~ $tolerable) {
+	    # Then we'll warn only if you've asked for warnings
+	    if (warnings::enabled()) {
+		if ($keywords{$name}) {
+		    warnings::warn("Constant name '$name' is a Perl keyword");
+		} elsif ($forced_into_main{$name}) {
+		    warnings::warn("Constant name '$name' is " .
+			"forced into package main::");
+		}
+	    }
+
+	# Looks like a boolean
+	# use constant FRED == fred;
+	} elsif ($name =~ $boolean) {
+            require Carp;
+	    if (@_) {
+		Carp::croak("Constant name '$name' is invalid");
+	    } else {
+		Carp::croak("Constant name looks like boolean value");
+	    }
+
+	} else {
+	   # Must have bad characters
+            require Carp;
+	    Carp::croak("Constant name '$name' has invalid characters");
+	}
+
+	{
+	    no strict 'refs';
+	    my $full_name = "${pkg}::$name";
+	    $declared{$full_name}++;
+	    if ($multiple || @_ == 1) {
+		my $scalar = $multiple ? $constants->{$name} : $_[0];
+
+		# Work around perl bug #xxxxx: Sub names (actually glob
+		# names in general) ignore the UTF8 flag. So we have to
+		# turn it off to get the "right" symbol table entry.
+		utf8::is_utf8 $name and utf8::encode $name;
+
+		# The constant serves to optimise this entire block out on
+		# 5.8 and earlier.
+		if (_CAN_PCS && $symtab && !exists $symtab->{$name}) {
+		    # No typeglob yet, so we can use a reference as space-
+		    # efficient proxy for a constant subroutine
+		    # The check in Perl_ck_rvconst knows that inlinable
+		    # constants from cv_const_sv are read only. So we have to:
+		    Internals::SvREADONLY($scalar, 1);
+		    $symtab->{$name} = \$scalar;
+		    ++$flush_mro;
+		} else {
+		    *$full_name = sub () { $scalar };
+		}
+	    } elsif (@_) {
+		my @list = @_;
+		*$full_name = sub () { @list };
+	    } else {
+		*$full_name = sub () { };
+	    }
+	}
+    }
+    # Flush the cache exactly once if we make any direct symbol table changes.
+    mro::method_changed_in($pkg) if _CAN_PCS && $flush_mro;
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+constant - Perl pragma to declare constants
+
+=head1 SYNOPSIS
+
+    use constant PI    => 4 * atan2(1, 1);
+    use constant DEBUG => 0;
+
+    print "Pi equals ", PI, "...\n" if DEBUG;
+
+    use constant {
+        SEC   => 0,
+        MIN   => 1,
+        HOUR  => 2,
+        MDAY  => 3,
+        MON   => 4,
+        YEAR  => 5,
+        WDAY  => 6,
+        YDAY  => 7,
+        ISDST => 8,
+    };
+
+    use constant WEEKDAYS => qw(
+        Sunday Monday Tuesday Wednesday Thursday Friday Saturday
+    );
+
+    print "Today is ", (WEEKDAYS)[ (localtime)[WDAY] ], ".\n";
+
+=head1 DESCRIPTION
+
+This pragma allows you to declare constants at compile-time.
+
+When you declare a constant such as C<PI> using the method shown
+above, each machine your script runs upon can have as many digits
+of accuracy as it can use. Also, your program will be easier to
+read, more likely to be maintained (and maintained correctly), and
+far less likely to send a space probe to the wrong planet because
+nobody noticed the one equation in which you wrote C<3.14195>.
+
+When a constant is used in an expression, Perl replaces it with its
+value at compile time, and may then optimize the expression further.
+In particular, any code in an C<if (CONSTANT)> block will be optimized
+away if the constant is false.
+
+=head1 NOTES
+
+As with all C<use> directives, defining a constant happens at
+compile time. Thus, it's probably not correct to put a constant
+declaration inside of a conditional statement (like C<if ($foo)
+{ use constant ... }>).
+
+Constants defined using this module cannot be interpolated into
+strings like variables.  However, concatenation works just fine:
+
+    print "Pi equals PI...\n";        # WRONG: does not expand "PI"
+    print "Pi equals ".PI."...\n";    # right
+
+Even though a reference may be declared as a constant, the reference may
+point to data which may be changed, as this code shows.
+
+    use constant ARRAY => [ 1,2,3,4 ];
+    print ARRAY->[1];
+    ARRAY->[1] = " be changed";
+    print ARRAY->[1];
+
+Dereferencing constant references incorrectly (such as using an array
+subscript on a constant hash reference, or vice versa) will be trapped at
+compile time.
+
+Constants belong to the package they are defined in.  To refer to a
+constant defined in another package, specify the full package name, as
+in C<Some::Package::CONSTANT>.  Constants may be exported by modules,
+and may also be called as either class or instance methods, that is,
+as C<< Some::Package->CONSTANT >> or as C<< $obj->CONSTANT >> where
+C<$obj> is an instance of C<Some::Package>.  Subclasses may define
+their own constants to override those in their base class.
+
+The use of all caps for constant names is merely a convention,
+although it is recommended in order to make constants stand out
+and to help avoid collisions with other barewords, keywords, and
+subroutine names. Constant names must begin with a letter or
+underscore. Names beginning with a double underscore are reserved. Some
+poor choices for names will generate warnings, if warnings are enabled at
+compile time.
+
+=head2 List constants
+
+Constants may be lists of more (or less) than one value.  A constant
+with no values evaluates to C<undef> in scalar context.  Note that
+constants with more than one value do I<not> return their last value in
+scalar context as one might expect.  They currently return the number
+of values, but B<this may change in the future>.  Do not use constants
+with multiple values in scalar context.
+
+B<NOTE:> This implies that the expression defining the value of a
+constant is evaluated in list context.  This may produce surprises:
+
+    use constant TIMESTAMP => localtime;                # WRONG!
+    use constant TIMESTAMP => scalar localtime;         # right
+
+The first line above defines C<TIMESTAMP> as a 9-element list, as
+returned by C<localtime()> in list context.  To set it to the string
+returned by C<localtime()> in scalar context, an explicit C<scalar>
+keyword is required.
+
+List constants are lists, not arrays.  To index or slice them, they
+must be placed in parentheses.
+
+    my @workdays = WEEKDAYS[1 .. 5];            # WRONG!
+    my @workdays = (WEEKDAYS)[1 .. 5];          # right
+
+=head2 Defining multiple constants at once
+
+Instead of writing multiple C<use constant> statements, you may define
+multiple constants in a single statement by giving, instead of the
+constant name, a reference to a hash where the keys are the names of
+the constants to be defined.  Obviously, all constants defined using
+this method must have a single value.
+
+    use constant {
+        FOO => "A single value",
+        BAR => "This", "won't", "work!",        # Error!
+    };
+
+This is a fundamental limitation of the way hashes are constructed in
+Perl.  The error messages produced when this happens will often be
+quite cryptic -- in the worst case there may be none at all, and
+you'll only later find that something is broken.
+
+When defining multiple constants, you cannot use the values of other
+constants defined in the same declaration.  This is because the
+calling package doesn't know about any constant within that group
+until I<after> the C<use> statement is finished.
+
+    use constant {
+        BITMASK => 0xAFBAEBA8,
+        NEGMASK => ~BITMASK,                    # Error!
+    };
+
+=head2 Magic constants
+
+Magical values and references can be made into constants at compile
+time, allowing for way cool stuff like this.  (These error numbers
+aren't totally portable, alas.)
+
+    use constant E2BIG => ($! = 7);
+    print   E2BIG, "\n";        # something like "Arg list too long"
+    print 0+E2BIG, "\n";        # "7"
+
+You can't produce a tied constant by giving a tied scalar as the
+value.  References to tied variables, however, can be used as
+constants without any problems.
+
+=head1 TECHNICAL NOTES
+
+In the current implementation, scalar constants are actually
+inlinable subroutines. As of version 5.004 of Perl, the appropriate
+scalar constant is inserted directly in place of some subroutine
+calls, thereby saving the overhead of a subroutine call. See
+L<perlsub/"Constant Functions"> for details about how and when this
+happens.
+
+In the rare case in which you need to discover at run time whether a
+particular constant has been declared via this module, you may use
+this function to examine the hash C<%constant::declared>. If the given
+constant name does not include a package name, the current package is
+used.
+
+    sub declared ($) {
+        use constant 1.01;              # don't omit this!
+        my $name = shift;
+        $name =~ s/^::/main::/;
+        my $pkg = caller;
+        my $full_name = $name =~ /::/ ? $name : "${pkg}::$name";
+        $constant::declared{$full_name};
+    }
+
+=head1 CAVEATS
+
+In the current version of Perl, list constants are not inlined
+and some symbols may be redefined without generating a warning.
+
+It is not possible to have a subroutine or a keyword with the same
+name as a constant in the same package. This is probably a Good Thing.
+
+A constant with a name in the list C<STDIN STDOUT STDERR ARGV ARGVOUT
+ENV INC SIG> is not allowed anywhere but in package C<main::>, for
+technical reasons. 
+
+Unlike constants in some languages, these cannot be overridden
+on the command line or via environment variables.
+
+You can get into trouble if you use constants in a context which
+automatically quotes barewords (as is true for any subroutine call).
+For example, you can't say C<$hash{CONSTANT}> because C<CONSTANT> will
+be interpreted as a string.  Use C<$hash{CONSTANT()}> or
+C<$hash{+CONSTANT}> to prevent the bareword quoting mechanism from
+kicking in.  Similarly, since the C<< => >> operator quotes a bareword
+immediately to its left, you have to say C<< CONSTANT() => 'value' >>
+(or simply use a comma in place of the big arrow) instead of
+C<< CONSTANT => 'value' >>.
+
+=head1 SEE ALSO
+
+L<Readonly> - Facility for creating read-only scalars, arrays, hashes.
+
+L<Const> - Facility for creating read-only variables. Similar to C<Readonly>,
+but uses C<SvREADONLY> instead of C<tie>.
+
+L<Attribute::Constant> - Make read-only variables via attribute
+
+L<Scalar::Readonly> - Perl extension to the C<SvREADONLY> scalar flag
+
+L<Hash::Util> - A selection of general-utility hash subroutines (mostly
+to lock/unlock keys and values)
+
+=head1 BUGS
+
+Please report any bugs or feature requests via the perlbug(1) utility.
+
+=head1 AUTHORS
+
+Tom Phoenix, E<lt>F<rootbeer@redcat.com>E<gt>, with help from
+many other folks.
+
+Multiple constant declarations at once added by Casey West,
+E<lt>F<casey@geeknest.com>E<gt>.
+
+Documentation mostly rewritten by Ilmari Karonen,
+E<lt>F<perl@itz.pp.sci.fi>E<gt>.
+
+This program is maintained by the Perl 5 Porters. 
+The CPAN distribution is maintained by SE<eacute>bastien Aperghis-Tramoni
+E<lt>F<sebastien@aperghis.net>E<gt>.
+
+=head1 COPYRIGHT & LICENSE
+
+Copyright (C) 1997, 1999 Tom Phoenix
+
+This module is free software; you can redistribute it or modify it
+under the same terms as Perl itself.
+
+=cut

data/Slic3r/Linux/lib/std/constant/defer.pm

@@ -0,0 +1,441 @@
+# Copyright 2008, 2009, 2010, 2011 Kevin Ryde
+
+# This file is part of constant-defer.
+#
+# constant-defer is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the Free
+# Software Foundation; either version 3, or (at your option) any later
+# version.
+#
+# constant-defer is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with constant-defer.  If not, see <http://www.gnu.org/licenses/>.
+
+package constant::defer;
+use strict;
+use vars qw($VERSION);
+
+$VERSION = 5;
+
+sub import {
+  my $class = shift;
+  $class->_create_for_package (scalar(caller), @_);
+}
+sub _create_for_package {
+  my $class = shift;
+  my $target_package = shift;
+  while (@_) {
+    my $name = shift;
+    if (ref $name eq 'HASH') {
+      unshift @_, %$name;
+      next;
+    }
+    unless (@_) {
+      require Carp;
+      Carp::croak ("Missing value sub for $name");
+    }
+    my $subr = shift;
+
+    ### $constant::defer::DEBUG_LAST_SUBR = $subr;
+
+    my ($fullname, $basename);
+    if ($name =~ /::([^:]*)$/s) {
+      $fullname = $name;
+      $basename = $1;
+    } else {
+      $basename = $name;
+      $fullname = "${target_package}::$name";
+    }
+    ## print "constant::defer $arg -- $fullname $basename $old\n";
+    $class->_validate_name ($basename);
+    $class->_create_fullname ($fullname, $subr);
+  }
+}
+
+sub _create_fullname {
+  my ($class, $fullname, $subr) = @_;
+  my $run = sub {
+    unshift @_, $fullname, $subr;
+    goto &_run;
+  };
+  my $func = sub () {
+    unshift @_, \$run;
+    goto $run;
+  };
+  no strict 'refs';
+  *$fullname = $func;
+
+  ### $constant::defer::DEBUG_LAST_RUNNER = $run;
+}
+
+sub _run {
+  my $fullname = shift;
+  my $subr = shift;
+  my $run_ref = shift;
+  ### print "_run() $fullname $subr\n";
+
+  my @ret = &$subr(@_);
+  if (@ret == 1) {
+    # constant.pm has an optimization to make a constant by storing a scalar
+    # value directly into the %{Foo::Bar::} hash if there's no typeglob for
+    # the name yet.  But that doesn't apply here, there's always a glob from
+    # having converted a function.
+    #
+    # The function created only has name __ANON__ in its coderef GV (as
+    # fetched by Sub::Identify for instance).  This is the same as most
+    # function creating modules, including Memoize.pm.  Plain constant.pm
+    # likewise, except when it uses the scalar ref in symbol table
+    # optimization, in that case a later upgrade to a function gets a name.
+    #
+    my $value = $ret[0];
+    $subr = sub () { $value };
+
+  } elsif (@ret == 0) {
+    $subr = \&_nothing;
+
+  } else {
+    $subr = sub () { @ret };
+  }
+
+  $$run_ref = $subr;
+  { no strict 'refs';
+    local $^W = 0; # no warnings 'redefine';
+    eval { *$fullname = $subr } or die $@;
+  }
+  goto $subr;
+}
+
+# not as strict as constant.pm
+sub _validate_name {
+  my ($class, $name) = @_;
+  if ($name =~ m{[()]   # no parens like CODE(0x1234) if miscounted args
+               |^[0-9]  # no starting with a number
+               |^$      # not empty
+              }x) {
+    require Carp;
+    Carp::croak ("Constant name '$name' is invalid");
+  }
+}
+
+sub _nothing () { } ## no critic (ProhibitSubroutinePrototypes)
+
+1;
+__END__
+
+=for stopwords bareword stringizing inline there'd fakery subclassing Ryde multi-value inlined coderef subrs subr
+
+=head1 NAME
+
+constant::defer -- constant subs with deferred value calculation
+
+=for test_synopsis my ($some,$thing,$an,$other);
+
+=head1 SYNOPSIS
+
+ use constant::defer FOO => sub { return $some + $thing; },
+                     BAR => sub { return $an * $other; };
+
+ use constant::defer MYOBJ => sub { require My::Class;
+                                    return My::Class->new_thing; }
+
+=head1 DESCRIPTION
+
+C<constant::defer> creates a subroutine which on the first call runs given
+code to calculate its value, and on the second and subsequent calls just
+returns that value, like a constant.  The value code is discarded once run,
+allowing it to be garbage collected.
+
+Deferring a calculation is good if it might take a lot of work or produce a
+big result, but is only needed sometimes or only well into a program run.
+If it's never needed then the value code never runs.
+
+A deferred constant is generally not inlined or folded (see
+L<perlop/Constant Folding>) like a plain C<constant> since it's not a single
+scalar value.  In the current implementation a deferred constant becomes a
+plain one after the first use, so may inline etc in code compiled after that
+(see L</IMPLEMENTATION> below).
+
+=head2 Uses
+
+Here are some typical uses.
+
+=over 4
+
+=item *
+
+A big value or slow calculation only sometimes needed,
+
+    use constant::defer SLOWVALUE => sub {
+                          long calculation ...;
+                          return $result;
+                        };
+
+    if ($option) {
+      print "s=", SLOWVALUE, "\n";
+    }
+
+=item *
+
+A shared object instance created when needed then re-used,
+
+    use constant::defer FORMATTER =>
+          sub { return My::Formatter->new };
+
+    if ($something) {
+      FORMATTER()->format ...
+    }
+
+=item *
+
+The value code might load requisite modules too, again deferring that until
+actually needed,
+
+    use constant::defer big => sub {
+      require Some::Big::Module;
+      return Some::Big::Module->create_something(...);
+    };
+
+=item *
+
+Once-only setup code can be created with no return value.  The code is
+garbage collected after the first run and becomes a do-nothing.  Remember to
+have an empty return statement so as not to keep the last expression's value
+alive forever.
+
+    use constant::defer MY_INIT => sub {
+      many lines of setup code ...;
+      return;
+    };
+
+    sub new {
+      MY_INIT();
+      ...
+    }
+
+=back
+
+=head1 IMPORTS
+
+There are no functions as such, everything works through the C<use> import.
+
+=over 4
+
+=item C<< use constant::defer NAME1=>SUB1, NAME2=>SUB2, ...; >>
+
+The parameters are name/subroutine pairs.  For each one a sub called C<NAME>
+is created, running the given C<SUB> the first time its value is needed.
+
+C<NAME> defaults to the caller's package, or a fully qualified name can be
+given.  Remember that the bareword stringizing of C<=E<gt>> doesn't act on a
+qualified name, so add quotes in that case.
+
+    use constant::defer 'Other::Package::BAR' => sub { ... };
+
+For compatibility with the C<constant> module a hash of name/sub arguments
+is accepted too.  But C<constant::defer> doesn't need that since there's
+only ever one thing (a sub) following each name.
+
+    use constant::defer { FOO => sub { ... },
+                          BAR => sub { ... } };
+
+    # works without the hashref too
+    use constant::defer FOO => sub { ... },
+                        BAR => sub { ... };
+
+=back
+
+=head1 MULTIPLE VALUES
+
+The value sub can return multiple values to make an array style constant
+sub.
+
+    use constant::defer NUMS => sub { return ('one', 'two') };
+
+    foreach (NUMS) {
+       print $_,"\n";
+    }
+
+The value sub is always run in array context, for consistency, irrespective
+how the constant is used.  The return from the new constant sub is an array
+style
+
+    sub () { return @result }
+
+If the value sub was a list-style return like C<NUMS> shown above, then this
+array-style return is slightly different.  In scalar context a list return
+means the last value (like a comma operator), but an array return in scalar
+context means the number of elements.  A multi-value constant won't normally
+be used in scalar context, so the difference shouldn't arise.  The array
+style is easier for C<constant::defer> to implement and is the same as the
+plain C<constant> module does.
+
+=head1 ARGUMENTS
+
+If the constant is called with arguments then they're passed on to the value
+sub.  This can be good for constants used as object or class methods.
+Passing anything to plain constants would be unusual.
+
+One cute use for a class method style is to make a "singleton" instance of
+the class.  See F<examples/instance.pl> in the sources for a complete
+program.
+
+    package My::Class;
+    use constant::defer INSTANCE => sub { my ($class) = @_;
+                                          return $class->new };
+    package main;
+    $obj = My::Class->INSTANCE;
+
+A subclass might want to be careful about letting a subclass object get into
+the parent C<INSTANCE>, though if a program only ever used the subclass then
+that might in fact be desirable.
+
+Subs created by C<constant::defer> always have prototype C<()>, ensuring
+they always parse the same way.  The prototype has no effect when called as
+a method like above, but if you want a plain call with arguments then use
+C<&> to bypass the prototype (see L<perlsub>).
+
+    &MYCONST ('Some value');
+
+=head1 IMPLEMENTATION
+
+Currently C<constant::defer> creates a sub under the requested name and when
+called it replaces that with a new constant sub the same as C<use constant>
+would make.  This is compact and means that later loaded code might be able
+to inline it.
+
+It's fine to keep a reference to the initial sub and in fact that happens
+quite normally if importing into another module (with the usual
+C<Exporter>), or an explicit C<\&foo>, or a C<$package-E<gt>can('foo')>.
+The initial sub changes itself to jump to the new constant, it doesn't
+re-run the value code.
+
+The jump is currently done by a C<goto> to the new coderef, so it's a touch
+slower than the new constant sub directly.  A spot of XS would no doubt make
+the difference negligible, in fact perhaps to the point where there'd be no
+need for a new sub, just have the initial transform itself.  If the new form
+looked enough like a plain constant it might inline in later loaded code.
+
+For reference, C<Package::Constants> (as of version 0.02) considers
+C<constant::defer> subrs as constants, both before and after the first call
+that runs the value code.  C<Package::Constants> just looks for prototyped
+S<C<sub foo () { }>> functions, so any such subr rates as a constant.
+
+=head1 OTHER WAYS TO DO IT
+
+There's many ways to do "deferred" or "lazy" calculations.
+
+=over 4
+
+=item *
+
+C<Memoize> makes a function repeat its return.  Results are cached against
+the arguments, so it keeps the original code whereas C<constant::defer>
+discards after the first run.
+
+=item *
+
+C<Class::Singleton> and friends make a create-once
+C<My::Class-E<gt>instance> method.  C<constant::defer> can get close with
+the fakery shown under L</ARGUMENTS> above, though without a C<has_instance>
+to query.
+
+=item *
+
+C<Sub::Become> offers some syntactic sugar for redefining the running
+subroutine, including to a constant.
+
+=item *
+
+C<Sub::SingletonBuilder> can create an instance function for a class.  It's
+geared towards objects and so won't allow 0 or C<undef> as the return value.
+
+=item *
+
+A scalar can be rigged up to run code on its first access.  C<Data::Lazy>
+uses a C<tie>.  C<Scalar::Defer> and C<Scalar::Lazy> use C<overload> on an
+object.  C<Data::Thunk> optimizes out the object from C<Scalar::Defer> after
+the first run.  C<Variable::Lazy> uses XS magic removed after the first
+fetch and some parsing for syntactic sugar.
+
+The advantage of a variable is that it interpolates in strings, but it won't
+inline in later loaded code; sloppy XS code might bypass the magic; and
+package variables aren't very friendly when subclassing.
+
+=item *
+
+C<Object::Lazy> and C<Object::Trampoline> rig up an object wrapper to load
+and create an actual object only when a method is called, dispatching to it
+and replacing the callers C<$_[0]>.  The advantage is you can pass the
+wrapper object around, etc, deferring creation to an even later point than a
+sub or scalar can.
+
+=item *
+
+C<Object::Realize::Later>, C<Class::LazyObject> and C<Class::LazyFactory>
+help make a defer class which transforms lazy stub objects to real ones when
+a method call is made.  A separate defer class is required for each real
+class.
+
+=item *
+
+C<once.pm> sets up a run-once code block, but with no particular return
+value and not discarding the code after run.
+
+=item *
+
+C<Class::LazyLoad> and C<deferred> load code on a class method call such as
+object creation.  They're more about module loading than a defer of a
+particular value.
+
+=item *
+
+C<Tie::LazyList> and C<Tie::Array::Lazy> makes an array calculate values
+on-demand from a generator function.  C<Hash::Lazy> does a similar thing for
+hashes.  C<Tie::LazyFunction> hides a function behind a scalar; its laziness
+is in the argument evaluation, the function is called every time.
+
+=back
+
+=head1 SEE ALSO
+
+L<constant>, L<perlsub>, L<constant::lexical>
+
+L<Memoize>, L<Attribute::Memoize>, L<Memoize::Attrs>,
+L<Class::Singleton>,
+L<Data::Lazy>, L<Scalar::Defer>, L<Scalar::Lazy>, L<Data::Thunk>,
+L<Variable::Lazy>,
+L<Sub::Become>,
+L<Sub::SingletonBuilder>,
+L<Object::Lazy>,
+L<Object::Trampoline>,
+L<Object::Realize::Later>,
+L<once>,
+L<Class::LazyLoad>,
+L<deferred>
+
+=head1 HOME PAGE
+
+http://user42.tuxfamily.org/constant-defer/index.html
+
+=head1 COPYRIGHT
+
+Copyright 2009, 2010, 2011 Kevin Ryde
+
+constant-defer is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+constant-defer is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+more details.
+
+You should have received a copy of the GNU General Public License along with
+constant-defer.  If not, see <http://www.gnu.org/licenses/>.
+
+=cut