NAME

VSO - Very Simple Objects

DEPRECATED

Do not use. Look at Mo, Moo, Mouse or Moose instead.

SYNOPSIS

Basic point example:

  package Plane;
  use VSO;
  
  has 'width' => (
    is        => 'ro',
    isa       => 'Int',
  );
  
  has 'height' => (
    is        => 'ro',
    isa       => 'Int',
  );
  
  has 'points' => (
    is        => 'rw',
    isa       => 'ArrayRef[Point2d]',
    required  => 0,
  );


  package Point2d;
  use VSO;
  
  subtype 'ValidValue'
    => as      'Int'
    => where   { $_ >= 0 && $_ <= shift->plane->width }
    => message { 'Value must be between zero and ' . shift->plane->width };
  
  has 'plane' => (
    is        => 'ro',
    isa       => 'Plane',
    weak_ref  => 1,
  );
  
  has 'x' => (
    is        => 'rw',
    isa       => 'ValidValue'
  );
  
  has 'y' => (
    is        => 'rw',
    isa       => 'ValidValue'
  );
  
  after 'x' => sub {
    my ($s, $new_value, $old_value) = @_;
    warn "Moving $s from x$old_value to x$new_value";
  };
  
  after 'y' => sub {
    my ($s, $new_value, $old_value) = @_;
    warn "Moving $s from y$old_value to y$new_value";
  };

Fancy 3D Point:

  package Point3d;
  use VSO;
  
  extends 'Point2d';
  
  has 'z' => (
    is      => 'rw',
    isa     => 'Int',
  );

  sub greet { warn "Hello, World!" }
  
  before 'greet' => sub {
    warn "About to greet you";
  };
  
  after 'greet' => sub {
    warn "I have greeted you";
  };

Enums:

  package Foo;
  use VSO;

  enum 'DayOfWeek' => [qw( Sun Mon Tue Wed Thu Fri Sat )];

  has 'day' => (
    is        => 'ro',
    isa       => 'DayOfWeek',
    required  => 1,
  );

Coercions and Subtypes:

  package Ken;
  use VSO;

  subtype 'Number::Odd'
    => as       'Int'
    => where    { $_ % 2 }
    => message  { "$_ is not an odd number: %=:" . ($_ % 2) };

  subtype 'Number::Even'
    => as       'Int'
    => where    { (! $_) || ( $_ % 2 == 0 ) }
    => message  { "$_ is not an even number" };

  coerce 'Number::Odd'
    => from 'Int'
    => via  { $_ % 2 ? $_ : $_ + 1 };

  coerce 'Number::Even'
    => from 'Int'
    => via  { $_ % 2 ? $_ + 1 : $_ };

  has 'favorite_number' => (
    is        => 'ro',
    isa       => 'Number::Odd',
    required  => 1,
    coerce    => 1, # Otherwise no coercion is performed.
  );

  ...

  my $ken = Ken->new( favorite_number => 3 ); # Works
  my $ken = Ken->new( favorite_number => 6 ); # Works, because of coercion.

Compile-time Extension Syntax new in v0.024:

  package Root::Foo;
  use VSO;
  has ...;
  
  package Subclass::Foo;
  use VSO extends => 'Foo::Class'; # inheritance during compile-time, not runtime.
  
  package Subclass::Bar;
  use VSO extends => [qw( Foo::Class Bar::Class )]; # extend many at once.

DESCRIPTION

VSO aims to offer a declarative OO style for Perl with very little overhead, without being overly-minimalist.

VSO is a simplified Perl5 object type system similar to Moose, but simpler.

TYPES

VSO offers the following type system:

  Any
    Item
        Bool
        Undef
        Maybe[`a]
        Defined
            Value
                Str
                    Num
                        Int
                    ClassName
            Ref
                ScalarRef
                ArrayRef
                HashRef
                CodeRef
                RegexpRef
                GlobRef
                    FileHandle
                Object

The key differences are that everything is derived from Any and there are no roles.

VSO does not currently support roles. (This may change soon.)

"Another" Moose?

Yes, but not exactly. VSO is not intended as a drop-in replacement for Moose, Mouse, Moo or Mo. They are all doing a fantastic job and you should use them.

We've got a ways to go before version 1.000 is released, so don't get too excited if the documentation isn't quite finished or it's not clear why VSO was made.

AUTHOR

John Drago <jdrago_999@yahoo.com>

LICENSE

This software is Free software and may be used and redistributed under the same terms as perl itself.