GSP
Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Support
Contact Us
Online Help
Handbooks
Domain Status
Man Pages

FAQ
Virtual Servers
Pricing
Billing
Technical

Network
Facilities
Connectivity
Topology Map

Miscellaneous
Server Agreement
Year 2038
Credits
 

USA Flag

 

 

Man Pages


Manual Reference Pages  -  DATA::OBJECT (3)

.ds Aq ’

NAME

Data::Object - Object Orientation for Perl 5

CONTENTS

VERSION

version 0.59

SYNOPSIS



    use Data::Object;

    # returns a code object
    my $object = Data::Object->new(sub{ join  , @_ });

    # returns true
    $object->isa(Data::Object::Code);

    # returns a string object
    my $string = $code->call(Hello, World);

    # returns a new string object
    $string = $string->split()->reverse->join()->uppercase;

    # returns a number object (returns true) and outputs "DLROW OLLEH"
    my $result = $string->say;

    # returns true
    $result->isa(Data::Object::Number);



DESCRIPTION

Data::Object is a framework for writing structured and highly object-oriented Perl 5 software programs. Additionally, this distribution provides classes which wrap Perl 5 native data types and provides methods for operating on the data.

EXPORTS

    all



    use Data::Object qw(:all);



The all export tag will export all exportable functions.

    core



    use Data::Object qw(:core);



The core export tag will export the exportable functions const, deduce, deduce_deep, detract, detract_deep, immutable, load, prototype, reify, and throw exclusively.

    data



    use Data::Object qw(:data);



The data export tag will export all exportable functions whose names are prefixed with the word data.

    type



    use Data::Object qw(:type);



The type export tag will export all exportable functions whose names are prefixed with the word type.

FUNCTIONS

    const



    # given 1.098765;

    const VERSION => 1.098765;



The const function creates a constant function using the name and expression supplied to it. A constant function is a function that does not accept any arguments and whose result(s) are deterministic.

    data_array



    # given [2..5];

    $object = data_array [2..5];
    $object->isa(Data::Object::Array);



The data_array function returns a Data::Object::Array instance which wraps the provided data type and can be used to perform operations on the data. The type_array function is an alias to this function.

    data_code



    # given sub { 1 };

    $object = data_code sub { 1 };
    $object->isa(Data::Object::Code);



The data_code function returns a Data::Object::Code instance which wraps the provided data type and can be used to perform operations on the data. The type_code function is an alias to this function.

    data_float



    # given 5.25;

    $object = data_float 5.25;
    $object->isa(Data::Object::Float);



The data_float function returns a Data::Object::Float instance which wraps the provided data type and can be used to perform operations on the data. The type_float function is an alias to this function.

    data_hash



    # given {1..4};

    $object = data_hash {1..4};
    $object->isa(Data::Object::Hash);



The data_hash function returns a Data::Object::Hash instance which wraps the provided data type and can be used to perform operations on the data. The type_hash function is an alias to this function.

    data_integer



    # given -100;

    $object = data_integer -100;
    $object->isa(Data::Object::Integer);



The data_integer function returns a Data::Object::Object instance which wraps the provided data type and can be used to perform operations on the data. The type_integer function is an alias to this function.

    data_number



    # given 100;

    $object = data_number 100;
    $object->isa(Data::Object::Number);



The data_number function returns a Data::Object::Number instance which wraps the provided data type and can be used to perform operations on the data. The type_number function is an alias to this function.

    data_regexp



    # given qr/test/;

    $object = data_regexp qr/test/;
    $object->isa(Data::Object::Regexp);



The data_regexp function returns a Data::Object::Regexp instance which wraps the provided data type and can be used to perform operations on the data. The type_regexp function is an alias to this function.

    data_scalar



    # given \*main;

    $object = data_scalar \*main;
    $object->isa(Data::Object::Scalar);



The data_scalar function returns a Data::Object::Scalar instance which wraps the provided data type and can be used to perform operations on the data. The type_scalar function is an alias to this function.

    data_string



    # given abcdefghi;

    $object = data_string abcdefghi;
    $object->isa(Data::Object::String);



The data_string function returns a Data::Object::String instance which wraps the provided data type and can be used to perform operations on the data. The type_string function is an alias to this function.

    data_undef



    # given undef;

    $object = data_undef undef;
    $object->isa(Data::Object::Undef);



The data_undef function returns a Data::Object::Undef instance which wraps the provided data type and can be used to perform operations on the data. The type_undef function is an alias to this function.

    data_universal



    # given 0;

    $object = data_universal 0;
    $object->isa(Data::Object::Universal);



The data_universal function returns a Data::Object::Universal instance which wraps the provided data type and can be used to perform operations on the data. The type_universal function is an alias to this function.

    deduce



    # given qr/\w+/;

    $object = deduce qr/\w+/;
    $object->isa(Data::Object::Regexp);



The deduce function returns a data type object instance based upon the deduced type of data provided.

    deduce_deep



    # given {1,2,3,{4,5,6,[-1]}}

    $deep = deduce_deep {1,2,3,{4,5,6,[-1]}};

    # Data::Object::Hash {
    #     1 => Data::Object::Number ( 2 ),
    #     3 => Data::Object::Hash {
    #          4 => Data::Object::Number ( 5 ),
    #          6 => Data::Object::Array [ Data::Object::Integer ( -1 ) ],
    #     },
    # }



The deduce_deep function returns a data type object. If the data provided is complex, this function traverses the data converting all nested data to objects. Note: Blessed objects are not traversed.

    deduce_type



    # given qr/\w+/;

    $type = deduce_type qr/\w+/; # REGEXP



The deduce_type function returns a data type description for the type of data provided, represented as a string in capital letters.

    detract



    # given bless({1..4}, Data::Object::Hash);

    $object = detract $object; # {1..4}



The detract function returns a value of native type, based upon the underlying reference of the data type object provided.

    detract_deep



    # given {1,2,3,{4,5,6,[-1, 99, bless({}), sub { 123 }]}};

    my $object = deduce_deep $object;
    my $revert = detract_deep $object; # produces ...

    # {
    #     1 => 2,
    #     3 => {
    #         4 => 5,
    #         6 => [ -1, 99, bless({}, main), sub { ... } ]
    #       }
    # }



The detract_deep function returns a value of native type. If the data provided is complex, this function traverses the data converting all nested data type objects into native values using the objects underlying reference. Note: Blessed objects are not traversed.

    immutable



    # given [1,2,3];

    $object = immutable data_array [1,2,3];
    $object->isa(Data::Object::Array); # via Data::Object::Immutable



The immutable function makes the data type object provided immutable. This function loads Data::Object::Immutable and returns the object provided as an argument.

    load



    # given List::Util;

    $package = load List::Util; # List::Util if loaded



The load function attempts to dynamically load a module and either dies or returns the package name of the loaded module.

    prototype



    # given ($name => [is => ro]);

    my $proto  = data_prototype $name => [is => ro];
    my $class  = $proto->create; # via Data::Object::Prototype
    my $object = $class->new(name => ...);



The prototype function returns a prototype object which can be used to generate classes, objects, and derivatives. This function loads Data::Object::Prototype and returns an object based on the arguments provided.

    reify



    # given [1..9];

    $array = reify [1..9]; # Data::Object::Array



The reify function will determine the type of the value provided and return it as a data type object. This method is an alias to the deduce_deep function.

    throw



    # given $message;

    throw $message; # An exception (...) was thrown in -e at line 1



The throw function will dynamically load and throw an exception object. This function takes all arguments accepted by the Data::Object::Exception class.

SEE ALSO

o Data::Object::Array
o Data::Object::Class
o Data::Object::Class::Syntax
o Data::Object::Code
o Data::Object::Float
o Data::Object::Hash
o Data::Object::Integer
o Data::Object::Number
o Data::Object::Role
o Data::Object::Role::Syntax
o Data::Object::Regexp
o Data::Object::Scalar
o Data::Object::String
o Data::Object::Undef
o Data::Object::Universal
o Data::Object::Autobox
o Data::Object::Immutable
o Data::Object::Library
o Data::Object::Prototype
o Data::Object::Signatures

AUTHOR

Al Newkirk <anewkirk@ana.io>

COPYRIGHT AND LICENSE

This software is copyright (c) 2014 by Al Newkirk.

This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.

Search for    or go to Top of page |  Section 3 |  Main Index


perl v5.20.3 DATA::OBJECT (3) 2015-11-29

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with manServer 1.07.