Type::Tiny::Manual::NonOO - phpMan

NAME
    Type::Tiny::Manual::NonOO - Type::Tiny in non-object-oriented code

MANUAL
    Although Type::Tiny was designed with object-oriented programming in
    mind, especially Moose-style classes and roles, it can be used in
    procedural and imperative programming.

    If you have read Type::Tiny::Manual::UsingWithMoo, you should understand
    how Type::Params can be used to validate method parametters. This same
    technique can be applied to regular subs too; just don't "shift" off
    $self. More information about checking parameters can be found in
    Type::Tiny::Manual::Params.

    The "is_*" and "assert_*" functions exported by type libraries may be
    useful in non-OO code too. See Type::Tiny::Manual::UsingWithMoo3.

  Type::Tiny and Smart Match
    Perl 5.10 introduced the smart match operator "~~", which has since been
    deprecated because though the general idea is fairly sound, the details
    were a bit messy.

    Nevertheless, Type::Tiny has support for smart match and I'm documenting
    it here because there's nowhere better to put it.

    The following can be used as to check if a value passes a type
    constraint:

      $value ~~ SomeType

    Where it gets weird is if $value is an object and overloads "~~". Which
    overload of "~~" wins? I don't know.

    Better to use:

      SomeType->check( $value )   # more reliable, probably faster
      is_SomeType($value)         # more reliable, definitely faster

    It's also possible to do:

      $value ~~ SomeType->coercion

    This checks to see if $value matches any type that can be coerced to
    SomeType.

    But better to use:

      SomeType->coercion->has_coercion_for_value( $value )

  "given" and "when"
    Related to the smart match operator is the "given"/"when" syntax.

    This will not do what you want it to do:

      use Types::Standard qw( Str Int );

      given ($value) {
        when (Int) { ... }
        when (Str) { ... }
      }

    This will do what you wanted:

      use Types::Standard qw( is_Str is_Int );

      given ($value) {
        when (\&is_Int) { ... }
        when (\&is_Str) { ... }
      }

    Sorry, that's just how Perl be.

    Better though:

      use Types::Standard qw( Str Int );
      use Type::Utils qw( match_on_type );

      match_on_type $value => (
        Str, sub { ... },
        Int, sub { ... },
      );

    If this is part of a loop or other frequently called bit of code, you
    can compile the checks once and use them many times:

      use Types::Standard qw( Str Int );
      use Type::Utils qw( compile_match_on_type );

      my $dispatch_table = compile_match_on_type(
        Str, sub { ... },
        Int, sub { ... },
      );

      $dispatch_table->($_) for @lots_of_values;

    As with most things in Type::Tiny, those coderefs can be replaced by
    strings of Perl code.

NEXT STEPS
    Here's your next step:

    *   Type::Tiny::Manual::Optimization

        Squeeze the most out of your CPU.

AUTHOR
    Toby Inkster <tobyink AT cpan.org>.

COPYRIGHT AND LICENCE
    This software is copyright (c) 2013-2014, 2017-2021 by Toby Inkster.

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

DISCLAIMER OF WARRANTIES
    THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
    WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
    MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.