Linda A Walsh > mem-0.4.5 > mem

Download:
mem-0.4.5.tar.gz

Dependencies

Annotate this POD

CPAN RT

Open  0
View/Report Bugs
Module Version: 0.4.5   Source  

NAME ^

VERSION ^

Version "0.4.5"

SYNOPSIS ^

  use mem;
  use mem(@COMPILE_TIME_DEFINES=qw(a b c));

mem is a trivial pragma to either allow defining the module it is included from as being defined so that later classes or packages in the same file can use the package to pull in a reference to it, or to be able to call its import routine from a different package in the same file.

With parameter assignments or other actions, it forces those assignments to be done, immediately, at compile time instead of later at run time. It can be use, for example, with Exporter, to export typed-sub's among other usages.

EXAMPLE ^

Following, is a sample program, showing two uses of mem.

  use strict; use warnings;

  { package Ar_Type;
      #
      use mem;                                    #1st usage 
      our (@EXPORT, @ISA);
      sub ARRAY (;*) {
          my $p = $_[0]; my $t="ARRAY";
          return @_ ? (ref $p && (1+index($p, $t))) : $t;
      }
      #
      use mem(                                    #2nd usage 
          @EXPORT=qw(ARRAY), @ISA=qw(Exporter)
      #
      )                                           #(also) 2nd usage 
      ;
      use Exporter;
  }

  package main;
  use Ar_Type;
  use P;
        use Types::Core

  my @a=(1,2,3);
  my ($ed, $light);
      (@$ed, @$light) = (@a, @a);  #ed & light point to copies of @a
  bless $ed, "bee";

  P "\@a = ref of array" if ARRAY \@a;
  P "ref of ed is %s", ref $ed;
  P "ed still points to underlying type, 'array'" if ARRAY $ed;
  P "Is ref \$light, ARRAY?: %s", (ref $light eq ARRAY) ? 'yes':'no';
  P "Does \"ref \$ed\" eq ARRAY?: %s", (ref $ed eq ARRAY) ? 'yes':'no';
  P "%s", "#  (Because \"ref \$ed\" is really a bless \"ed\" bee)"

Summary

The first usage allows 'main' to find package Ar_Type, already in memory.

The second usage forces the definition of 'ARRAY' into memory so they can be exported by an exporter function.

In both cases, mem allows your already-in-memory code to be used. Thsi allows simplified programming and usage without knowledge of or references to Perl's internal-flags or internal run phases.

SEE ALSO ^

See Exporter for information on exporting names. See the newer, Xporter for doing similar without the need for setting @ISA and persistent defaults in @EXPORT. See P for more details about the generic print verb and see Types::Core for a more complete treatment of the CORE Types.

syntax highlighting: