SYNOPSIS

        use Data::Object::Prototype;
    
        my $bear = object {
            name     => 'bear',
            type     => 'black bear',
            attitude => 'indifferent',
        };
    
        $bear->package->install(responds => sub {
            'Roarrrr'
        });
    
        $bear->package->install(succeeds => sub {
            shift->isa(ref shift)
        });
    
        my $papa = extend $bear => {
            name     => 'papa bear',
            type     => 'great big papa bear',
            attitude => 'agitated',
        };
    
        $papa->package->install(responds => sub {
            "Who's been eating my porridge?"
        });
    
        my $baby = extend $papa => {
            name     => 'baby bear',
            type     => 'tiny little baby bear',
            attitude => 'baby',
        };
    
        $baby->package->install(responds => sub {
            "Who's eaten up all my porridge?"
        });
    
        my $mama = extend $bear => {
            name     => 'mama bear',
            type     => 'middle-sized mama bear',
            attitude => 'confused',
        };
    
        $mama->package->install(responds => sub {
            "Who's been eating my porridge?"
        });
    
        if ($papa && $mama && $baby && $baby->succeeds($papa)) {
            my $statement = "The %s said, '%s'\n";
    
            printf $statement, $papa->get('name'), $papa->responds;
            printf $statement, $mama->get('name'), $mama->responds;
            printf $statement, $baby->get('name'), $baby->responds;
    
            # The Papa Bear said, "Who's been eating my porridge?"
            # The Mama Bear said, "Who's been eating my porridge?"
            # The Baby Bear said, "Who's eaten up all my porridge?"
        }

DESCRIPTION

    Data::Object::Prototype implements a thin prototype-like layer on top
    of the Data::Object type-object framework. This module allows you to
    develop using a prototype-based style in Perl, giving you the ability
    to create, mutate, extend, mixin, and destroy anonymous Data::Object
    type classes, ad hoc and with very little code.

    Prototype-based programming is a style of object-oriented programming
    in which classes are not present, and behavior reuse (known as
    inheritance in class-based languages) is performed via a process of
    cloning existing objects that serve as prototypes. Due to familiarity
    with class-based languages such as Java, many programmers assume that
    object-oriented programming is synonymous with class-based programming.

    However, class-based programming is just one kind of object-oriented
    programming style, and other varieties exist such as role-oriented,
    aspect-oriented and prototype-based programming. A prominent example of
    a prototype-based programming language is ECMAScript (a.k.a. JavaScript
    or JScript). Note: This is an early release available for testing and
    feedback and as such is subject to change.

