NAME

    Venus - OO Library

ABSTRACT

    OO Standard Library for Perl 5

VERSION

    0.09

SYNOPSIS

      package main;
    
      use Venus qw(
        catch
        error
        raise
      );
    
      # error handling
      my ($error, $result) = catch {
        error;
      };
    
      # boolean keywords
      if ($result and $result eq false) {
        true;
      }
    
      # raise exceptions
      if (false) {
        raise 'MyApp::Error';
      }
    
      # and much more!
      true ne false;

DESCRIPTION

    This library provides an object-orientation framework and extendible
    standard library for Perl 5, built on top of Moo with classes which
    wrap most native Perl data types. Venus has a simple modular
    architecture, robust library of classes and methods, supports pure-Perl
    autoboxing, advanced exception handling, "true" and "false" keywords,
    package introspection, command-line options parsing, and more. This
    package will always automatically exports true and false keyword
    functions (unless existing routines of the same name already exist in
    the calling package), otherwise exports keyword functions as requested
    at import. This library requires Perl 5.18+.

FUNCTIONS

    This package provides the following functions:

 catch

      catch(CodeRef $block) (Error, Any)

    The catch function executes the code block trapping errors and
    returning the caught exception in scalar context, and also returning
    the result as a second argument in list context.

    Since 0.01

    catch example 1

        package main;
      
        use Venus 'catch';
      
        my $error = catch {die};
      
        $error; # 'Died at ...'

    catch example 2

        package main;
      
        use Venus 'catch';
      
        my ($error, $result) = catch {error};
      
        $error; # Venus::Error

    catch example 3

        package main;
      
        use Venus 'catch';
      
        my ($error, $result) = catch {true};
      
        $result; # 1

 error

      error(Maybe[HashRef] $args) (Error)

    The error function throws a Venus::Error exception object using the
    exception object arguments provided.

    Since 0.01

    error example 1

        package main;
      
        use Venus 'error';
      
        my $error = error;

    error example 2

        package main;
      
        use Venus 'error';
      
        my $error = error {
          message => 'Something failed!',
        };

 false

      false() (Bool)

    The false function returns a falsy boolean value which is designed to
    be practically indistinguishable from the conventional numerical 0
    value.

    Since 0.01

    false example 1

        package main;
      
        use Venus;
      
        my $false = false;

    false example 2

        package main;
      
        use Venus;
      
        my $true = !false;

 raise

      raise(Str $class | Tuple[Str, Str] $class, Maybe[HashRef] $args) (Error)

    The raise function generates and throws a named exception object
    derived from Venus::Error, or provided base class, using the exception
    object arguments provided.

    Since 0.01

    raise example 1

        package main;
      
        use Venus 'raise';
      
        my $error = raise 'MyApp::Error';

    raise example 2

        package main;
      
        use Venus 'raise';
      
        my $error = raise ['MyApp::Error', 'Venus::Error'];

    raise example 3

        package main;
      
        use Venus 'raise';
      
        my $error = raise ['MyApp::Error', 'Venus::Error'], {
          message => 'Something failed!',
        };

 true

      true() (Bool)

    The true function returns a truthy boolean value which is designed to
    be practically indistinguishable from the conventional numerical 1
    value.

    Since 0.01

    true example 1

        package main;
      
        use Venus;
      
        my $true = true;

    true example 2

        package main;
      
        use Venus;
      
        my $false = !true;

FEATURES

    This package provides the following features:

    standard-library

      This library provides a Perl object-oriented standard library with
      value classes and consistently named methods.

      example 1

        package main;
      
        use Venus::Array;
      
        my $array = Venus::Array->new([1..4]);
      
        # $array->all(sub{ $_ > 0 });
        # $array->any(sub{ $_ > 0 });
        # $array->each(sub{ $_ > 0 });
        # $array->grep(sub{ $_ > 0 });
        # $array->map(sub{ $_ > 0 });
        # $array->none(sub{ $_ < 0 });
        # $array->one(sub{ $_ == 0 });
        # $array->random;
      
        use Venus::Hash;
      
        my $hash = Venus::Hash->new({1..8});
      
        # $hash->all(sub{ $_ > 0 });
        # $hash->any(sub{ $_ > 0 });
        # $hash->each(sub{ $_ > 0 });
        # $hash->grep(sub{ $_ > 0 });
        # $hash->map(sub{ $_ > 0 });
        # $hash->none(sub{ $_ < 0 });
        # $hash->one(sub{ $_ == 0 });
        # $hash->random;
      
        $array->count == $hash->count;

    value-classes

      This library provides value classes which wrap native Perl data types
      and provides methods for operating their values.

      example 1

        package main;
      
        use Venus::Array;
      
        my $array = Venus::Array->new;

      example 2

        package main;
      
        use Venus::Boolean;
      
        my $boolean = Venus::Boolean->new;

      example 3

        package main;
      
        use Venus::Code;
      
        my $code = Venus::Code->new;

      example 4

        package main;
      
        use Venus::Float;
      
        my $float = Venus::Float->new;

      example 5

        package main;
      
        use Venus::Hash;
      
        my $hash = Venus::Hash->new;

      example 6

        package main;
      
        use Venus::Number;
      
        my $number = Venus::Number->new;

      example 7

        package main;
      
        use Venus::Regexp;
      
        my $regexp = Venus::Regexp->new;

      example 8

        package main;
      
        use Venus::Scalar;
      
        my $scalar = Venus::Scalar->new;

      example 9

        package main;
      
        use Venus::String;
      
        my $string = Venus::String->new;

      example 10

        package main;
      
        use Venus::Undef;
      
        my $undef = Venus::Undef->new;

    builtin-autoboxing

      This library provides opt-in pure Perl autoboxing allowing you to
      chain methods calls across objects and values.

      example 1

        package main;
      
        use Venus::String;
      
        my $string = Venus::String->new('hello, world');
      
        $string->box->split(', ')->join(' ')->titlecase->unbox->get;
      
        # Hello World

    utility-classes

      This library provides serveral essential utility classes for
      performing common programming tasks.

      example 1

        package main;
      
        use Venus::Args;
      
        my $args = Venus::Args->new;

      example 2

        package main;
      
        use Venus::Box;
      
        my $box = Venus::Box->new;

      example 3

        package main;
      
        use Venus::Data;
      
        my $docs = Venus::Data->new->docs;

      example 4

        package main;
      
        use Venus::Date;
      
        my $date = Venus::Date->new;

      example 5

        package main;
      
        use Venus::Error;
      
        my $error = Venus::Error->new;

      example 6

        package main;
      
        use Venus::Json;
      
        my $json = Venus::Json->new;

      example 7

        package main;
      
        use Venus::Name;
      
        my $name = Venus::Name->new;

      example 8

        package main;
      
        use Venus::Opts;
      
        my $opts = Venus::Opts->new;

      example 9

        package main;
      
        use Venus::Path;
      
        my $path = Venus::Path->new;

      example 10

        package main;
      
        use Venus::Data;
      
        my $text = Venus::Data->new->text;

      example 11

        package main;
      
        use Venus::Space;
      
        my $space = Venus::Space->new;

      example 12

        package main;
      
        use Venus::Throw;
      
        my $throw = Venus::Throw->new;

      example 13

        package main;
      
        use Venus::Try;
      
        my $try = Venus::Try->new;

      example 14

        package main;
      
        use Venus::Type;
      
        my $type = Venus::Type->new;

      example 15

        package main;
      
        use Venus::Vars;
      
        my $vars = Venus::Vars->new;

      example 16

        package main;
      
        use Venus::Match;
      
        my $match = Venus::Match->new;

      example 17

        package main;
      
        use Venus::Process;
      
        my $process = Venus::Process->new;

      example 18

        package main;
      
        use Venus::Template;
      
        my $template = Venus::Template->new;

      example 19

        package main;
      
        use Venus::Yaml;
      
        my $yaml = Venus::Yaml->new;

    package-reflection

      This library provides a package reflection class, Venus::Space, which
      can be used to perform meta-programming on package spaces.

      example 1

        package main;
      
        use Venus::Space;
      
        my $space = Venus::Space->new('Venus');
      
        $space->do('tryload')->routines;

    exception-handling

      This library provides a framework for raising, i.e. generating and
      throwing, exception objects and catching them.

      example 1

        package MyApp;
      
        use Venus::Class;
      
        with 'Venus::Role::Throwable';
        with 'Venus::Role::Catchable';
      
        sub execute {
          my ($self) = @_;
      
          $self->throw->error;
        }
      
        package main;
      
        my $myapp = MyApp->new;
      
        my $error = $myapp->catch('execute');
      
        # $error->isa('MyApp::Error');

    composable-standards

      This library provides a library of composable roles which can be used
      to extend core behaviors to custom objects.

      example 1

        package MyApp;
      
        use Venus::Class;
      
        with 'Venus::Role::Dumpable';
        with 'Venus::Role::Stashable';
      
        package main;
      
        my $myapp = MyApp->new;
      
        $myapp->stash(greeting => 'hello world');
      
        $myapp->dump('stash');
      
        # '{"greeting" => "hello world"}'

    pluggable-library

      This library provides a mechanism for extending the standard library,
      i.e. value classes, using plugins which can be automatically
      discovered and invoked. (no monkey-patching necessary)

      example 1

        package Venus::String::Plugin::Base64;
      
        sub new {
          return bless {};
        }
      
        sub execute {
          my ($self, $string, @args) = @_;
      
          require MIME::Base64;
      
          return MIME::Base64::encode_base64($string->value);
        }
      
        package main;
      
        use Venus::String;
      
        my $string = Venus::String->new('hello, world');
      
        $string->base64;

    template-system

      This library provides a minimalistic templating system.

      example 1

        package main;
      
        use Venus::Template;
      
        my $template = Venus::Template->new(q(
          {{ if user.name }}
          Welcome, {{ user.name }}!
          {{ else user.name }}
          Welcome, friend!
          {{ end user.name }}
        ));
      
        $template->render;

AUTHORS

    Cpanery, cpanery@cpan.org

