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 (shown here with the '-all' import tag, as well) 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.)

## Undocumented for now, because Moops is a better solution.

If you import Moo, you get Moo and MooX::late (but you should really be using Moops instead):

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

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.