NAME
    Defaults::Modern - Yet another approach to modernistic Perl

SYNOPSIS
      use Defaults::Modern;

      # Function::Parameters + List::Objects::WithUtils + types ->
      fun to_immutable ( (ArrayRef | ArrayObj) $arr ) {
        # blessed() and confess() are available (amongst others):
        my $immutable = immarray( blessed $arr ? $arr->all : @$arr );
        confess 'No items in array!' unless $immutable->has_any;
        $immutable
      }

      package My::Foo {
        use Defaults::Modern;

        # define keyword for defining constants ->
        define ARRAY_MAX = 10;

        # Moo(se) with types ->
        use Moo;
        use MooX::late;

        has myarray => (
          isa => ArrayObj,
          is  => 'ro',
          writer  => '_set_myarray',
          # MooX::late allows us to coerce from an ArrayRef:
          coerce  => 1,
          default => sub { [] },
        );

        # Method with optional positional param and implicit $self ->
        method slice_to_max (Int $max = -1) {
          my $arr = $self->myarray;
          $self->_set_myarray( 
            $arr->sliced( 0 .. $max >= 0 ? $max : ARRAY_MAX )
          )
        }
      }

      # Optionally autobox list-type refs via List::Objects::WithUtils ->
      use Defaults::Modern 'autobox_lists';
      my $obj = +{ foo => 'bar', baz => 'quux' }->inflate;
      my $baz = $obj->baz;

      # See DESCRIPTION for complete details on imported functionality.

DESCRIPTION
    Yet another approach to writing Perl in a modern style.

    . . . also saves me extensive typing ;-)

    When you "use Defaults::Modern", you get:

    *   strict and fatal warnings except for "once"; additionally disallow
        bareword::filehandles and indirect method calls

    *   The "v5.14" feature set ("state", "say", "unicode_strings",
        "array_base") -- except for "switch", which is deprecated in newer
        perls

    *   carp, croak, and confess error reporting tools from Carp

    *   blessed, reftype, and weaken utilities from Scalar::Util

    *   All of the List::Objects::WithUtils object constructors (array,
        array_of, immarray, immarray_of, hash, hash_of, immhash, immhash_of)

    *   fun and method keywords from Function::Parameters

    *   The full Types::Standard set and List::Objects::Types -- useful in
        combination with Function::Parameters (see the "SYNOPSIS" and
        Function::Parameters POD)

    *   try and catch from Try::Tiny

    *   The path object constructor from Path::Tiny and related
        types/coercions from Types::Path::Tiny

    *   maybe and provided definedness-checking syntax sugar from
        PerlX::Maybe

    *   A define keyword for defining constants based on PerlX::Define

    *   The |M| match operator from match::simple

    *   The sswitch and nswitch switch/case constructs from Switch::Plain

    *   true.pm so you can skip adding '1;' to all of your modules

    If you want to automatically load (with the '-all' import tag) and
    register other Type::Registry compatible libraries (see Type::Library),
    they can be specified at import time:

      use Defaults::Modern
        -all,
        -with_types => [ 'Types::Mine' ],

    If you import the tag "autobox_lists", ARRAY and HASH type references
    are autoboxed via List::Objects::WithUtils:

      use Defaults::Modern 'autobox_lists';
      my $itr = [ 1 .. 10 ]->natatime(2);

    Moo and MooX::late are depended upon in order to guarantee their
    availability, but not automatically imported:

      use Moo;
      use MooX::late;
      use Defaults::Modern;

      has foo => (
        is  => 'ro',
        isa => ArrayObj,
        coerce  => 1,
        default => sub { [] },
      );

    (If you're building classes, you may want to look into namespace::clean
    / namespace::sweep or similar -- Defaults::Modern imports an awful lot
    of Stuff. Moops may be nicer to work with.)

SEE ALSO
    This package just glues together useful parts of CPAN, the most visible
    portions of which come from the following modules:

    Carp

    Function::Parameters

    List::Objects::WithUtils and List::Objects::Types

    match::simple

    Path::Tiny

    PerlX::Maybe

    Scalar::Util

    Switch::Plain

    Try::Tiny

    Types::Standard

    Type::Tiny

AUTHOR
    Jon Portnoy <avenj@cobaltirc.org>

    Licensed under the same terms as Perl.

    Inspired by Defaults::Mauke and Moops.

    The code backing the define keyword is forked from TOBYINK's
    PerlX::Define to avoid the Moops dependency and is copyright Toby
    Inkster.