NAME
    Moos - Moo s{imple,peedy,ingle}

SYNOPSIS
        package Foos;
        use Moos;

        extends 'Boos';

        has this => ();
        has that => 42;
        has other => (
            builder => 'build_other',
            lazy => 1,
        );

        sub BUILD {
            my $self = shift;
            # build, build, build
        }

        sub BUILDARGS {
            my ($self, @args) = @_;
            # munge, munge, munge
            return {%munged_args};
        }

DESCRIPTION
    Moos completes the M to Moose sequence of Perl OO modules.

    This one is pure Perl, no dependencies, single file and Moose compatible
    (for what it does). It is fairly minimal.

FEATURES
    Here's a quick list of the Moose compatible features that are supported
    by Moos:

    strict / warnings
        Turns on "strict" and "warnings" for you.

    extends
        For inheritance. "Moos::Object" is the default base class.

            package MyClass;
            extends 'MyBaseClass';

    new A constructor class method.

            my $object = MyClass->new(this => 'nice', that => 2);

    BUILD
        Custom object construction. If you define BUILD, it is passed the
        value of the new object during construction. You can modify the
        object. Any value you return is ignored.

            sub BUILD { my $self = shift; ... }

    Helpful exports
        The ever useful "blessed" (from Scalar::Util) and "confess" (from
        Carp) are exported to your namespace.

    has Accessor generator. Supports the "is", "default", "build", "lazy",
        "clearer", "predicate", "required" and "handles" options, described
        below.

            has this => ();

    is  Specify which type of attribute accessor to provide. The default is
        "rw", a read-write accessor. Read-only "ro" accessors are also
        supported.

            has this => ( is => "ro" );

    default
        Specify the sub to generate a default value.

            has this => ( default => sub { 42 } );

    builder
        Specify the method name to generate a default value.

            has this => ( builder => '_build_this' );
            has that => ( builder => 1 );  # accept default name for method

    lazy
        Don't generate defaults during object construction.

            has this => ( builder => '_build_this', lazy => 1 );

    clearer
        Creates a clearer method.

            has this => ( clearer => "clear_this" );
            has that => ( clearer => 1 );  # accept default name for method

    predicate
        Creates a predicate method, which can be used to check if the
        attribute is set or unset.

            has this => ( predicate => "has_this" );
            has that => ( predicate => 1 );  # accept default name for method

    required
        Require that a value for the attribute be provided to the
        constructor or generated during object construction.

            has this => ( required => 1 );

    handles
        Delegated method calls.

            has wheels => (handles => [qw/ roll /]);

        This accepts a hashref or arrayref, but not the other possibilities
        offered by Moose.

    Note that currently all accessors are read-write by default and all
    unknown options are silently ignored.

HAS DIFFERENCES
    Moos has a few differences from Moose, regarding it's accessor support
    (ie the 'has' function).

    The supported options detailed above are about the same as Moose. All
    other arguments are currently ignored. All generated accessors are 'rw'.
    So you can just say:

        has 'this';
        has that => ();

    Unlike the other Mo* modules, Moos also supports just specifying the
    default. If the number of arguments (after the name) is an odd number,
    then the first value is the default. The following forms are valid:

        has a => 42;
        has b => 'string' => (lazy => 1);
        has c => {};
        has d => [1, 2, 3, 4];

    These all result in creating a Moos "default" argument. If the default
    is an array or hash reference, a shallow copy is made.

DEV OPTIONS
    Moos has a couple builtin dev options. They are controlled by
    environment variables.

    PERL_MOOS_ACCESSOR_CALLS
        By setting this environment variable, Moos will warn everytime an
        accessor method is called.

    PERL_MOOS_XXX
        By setting the environment variable, Moos will export the XXX
        debugging keywords.

WHENCE
    I(ngy) created Moos during Pegex development. Pegex uses a clone of Moos
    called Pegex::Base.

    Pegex is a parser framework and needs to be fast. While looking into
    speed issues I noted that accessor calling was the biggest hit. I tried
    all the various Mo* solutions and Mouse was the fastest.

    I was happy until I remembered that Mouse uses XS, and for various
    reasons this broke my toolchain (TestML, Module::Install, etc).

    I tried to inline Moo into one file but failed, and ended up with this.
    I've shared Pegex::Base as Moos in case any other projects want it.

    Later on, Toby added a bunch of low-cost but very features from Moose.

ON SPEED
    In the end, I got Pegex to run even faster with Moos than it originally
    did with Mouse. I'll tell you my secret...

    <Accessors *(usually)* do not need to be method calls.>

    Replace these:

        my $foo = $self->foo;
        $self->foo($foo);

    with:

        my $foo = $self->{foo};
        $self->{foo} = $foo;

    And your code will be faster (and a bit uglier).

    The only time that you need to call an accessor method is when you are
    reading a property and it might invoke a "lazy" "builder" or "default"
    method. Otherwise you are just wasting time. At least with the minimal
    feature set offered by Moos.

    The PERL_MOOS_ACCESSOR_CALLS feature described above is for finding
    these method calls.

    Note that users of your module's accessor methods can still use the
    method calls like they would expect to.

    I'm sure I've missed some subtlties, and would be glad to hear opinions,
    but in the meantime I'm happy that my code is faster and pure Perl.

CREDITS
    Toby Inkster <tobyink@cpan.org> submitted a number of great pull
    requests, making Moos a little bit more like Moose.

SEE ALSO
    *   M

    *   Mo

    *   Moo

    *   Moos

    *   Moose

    *   Mouse

    *   Mousse

AUTHOR
    Ingy döt Net <ingy@cpan.org>

COPYRIGHT AND LICENSE
    Copyright (c) 2012. Ingy döt Net.

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

    See http://www.perl.com/perl/misc/Artistic.html

