Class-based would have it be done through @ISA. You, the user, would create a Collection::BoundedUniqueColl and have something like:

our @ISA = qw(
    Collection::Bounded
    Collection::Unique
    Collection::Generic
);
[download]

Then, each of these would overload add(), for example. Collection::Unique would do something like:

sub add {
    my $self = shift;
    my $thing = shift;

    return undef if $self->contains($thing);
    return $self->SUPER::add($thing);
}
[download]

And, likewise for all the other decorators.

To handle it at runtime (which is what Design Patterns suggests), each decorator would actually have an attribute being the object below (which could be the thing itself or another decorator). So, the add would look something like:

sub add {
    my $self = shift;
    my $thing = shift;

    my $collection = $self->{collection};
    return undef if $collection->contains($thing);

    return $collection->add($thing);
}
[download]

Within Collection::Decorator (which is the base for all Decorators), you'd have to have some sort of AUTOLOAD to handle every other function, sorta like:

sub AUTOLOAD {
    my $self = shift;
    my $func = our $AUTOLOAD;

    $func =~ s/.*:://;
    return $self->{collection}->$func;
}
[download]

Any thoughts?

------
We are the carpenters and bricklayers of the Information Age.

Don't go borrowing trouble. For programmers, this means Worry only about what you need to implement.