NAME

    Struct::Dumb - make simple lightweight record-like structures

SYNOPSIS

     use Struct::Dumb;
     
     struct Point => [qw( x y )];
    
     my $point = Point(10, 20);
    
     printf "Point is at (%d, %d)\n", $point->x, $point->y;
    
     $point->y = 30;
     printf "Point is now at (%d, %d)\n", $point->x, $point->y;


     struct Point3D => [qw( x y z )], named_constructor => 1;
    
     my $point3d = Point3D( z => 12, x => 100, y => 50 );
    
     printf "Point3d's height is %d\n", $point3d->z;


     struct Point3D => [qw( x y z )], predicate => "is_Point3D";
    
     my $point3d = Point3D( 1, 2, 3 );
    
     printf "This is a Point3D\n" if is_Point3D( $point3d );


     use Struct::Dumb qw( -named_constructors )
    
     struct Point3D => [qw( x y z ];
    
     my $point3d = Point3D( x => 100, z => 12, y => 50 );

DESCRIPTION

    Struct::Dumb creates record-like structure types, similar to the struct
    keyword in C, C++ or C#, or Record in Pascal. An invocation of this
    module will create a construction function which returns new object
    references with the given field values. These references all respond to
    lvalue methods that access or modify the values stored.

    It's specifically and intentionally not meant to be an object class.
    You cannot subclass it. You cannot provide additional methods. You
    cannot apply roles or mixins or metaclasses or traits or antlers or
    whatever else is in fashion this week.

    On the other hand, it is tiny, creates cheap lightweight array-backed
    structures, uses nothing outside of core. It's intended simply to be a
    slightly nicer way to store data structures, where otherwise you might
    be tempted to abuse a hash, complete with the risk of typoing key
    names. The constructor will croak if passed the wrong number of
    arguments, as will attempts to refer to fields that don't exist.
    Accessor-mutators will croak if invoked with arguments. (This helps
    detect likely bugs such as accidentally passing in the new value as an
    argument, or attempting to invoke a stored CODE reference by passing
    argument values directly to the accessor.)

     $ perl -E 'use Struct::Dumb; struct Point => [qw( x y )]; Point(30)'
     usage: main::Point($x, $y) at -e line 1
    
     $ perl -E 'use Struct::Dumb; struct Point => [qw( x y )]; Point(10,20)->z'
     main::Point does not have a 'z' field at -e line 1
    
     $ perl -E 'use Struct::Dumb; struct Point => [qw( x y )]; Point(1,2)->x(3)'
     main::Point->x invoked with arguments at -e line 1.

    Objects in this class are (currently) backed by an ARRAY reference
    store, though this is an internal implementation detail and should not
    be relied on by using code. Attempting to dereference the object as an
    ARRAY will throw an exception.

 CONSTRUCTOR FORMS

    The struct and readonly_struct declarations create two different kinds
    of constructor function, depending on the setting of the
    named_constructor option. When false, the constructor takes positional
    values in the same order as the fields were declared. When true, the
    constructor takes a key/value pair list in no particular order, giving
    the value of each named field.

    This option can be specified to the struct and readonly_struct
    functions. It defaults to false, but it can be set on a per-package
    basis to default true by supplying the -named_constructors option on
    the use statement.

FUNCTIONS

 struct

       struct $name => [ @fieldnames ],
          named_constructor => (1|0),
          predicate         => "is_$name";

    Creates a new structure type. This exports a new function of the type's
    name into the caller's namespace. Invoking this function returns a new
    instance of a type that implements those field names, as accessors and
    mutators for the fields.

    Takes the following options:

    named_constructor => BOOL

      Determines whether the structure will take positional or named
      arguments.

    predicate => STR

      If defined, gives the name of a second function to export to the
      caller's namespace. This function will be a type test predicate; that
      is, a function that takes a single argmuent, and returns true
      if-and-only-if that argument is an instance of this structure type.

 readonly_struct

       readonly_struct $name => [ @fieldnames ],
          ...

    Similar to "struct", but instances of this type are immutable once
    constructed. The field accessor methods will not be marked with the
    :lvalue attribute.

    Takes the same options as "struct".

NOTES

 Allowing ARRAY dereference

    The way that forbidding access to instances as if they were ARRAY
    references is currently implemented uses an internal method on the
    generated structure class called _forbid_arrayification. If special
    circumstances require that this exception mechanism be bypassed, the
    method can be overloaded with an empty sub {} body, allowing the struct
    instances in that class to be accessed like normal ARRAY references.
    For good practice this should be limited by a local override.

    For example, Devel::Cycle needs to access the instances as plain ARRAY
    references so it can walk the data structure looking for reference
    cycles.

     use Devel::Cycle;
    
     {
        no warnings 'redefine';
        local *Point::_forbid_arrayification = sub {};
    
        memory_cycle_ok( $point );
     }

TODO

      * Consider adding an coerce_hash option, giving name of another
      function to convert structs to key/value pairs, or a HASH ref.

AUTHOR

    Paul Evans <leonerd@leonerd.org.uk>

