Joseph Brenner
and 1 contributors

NAME

Scalar::Classify - get type and class information for scalars

SYNOPSIS

   use Scalar::Classify qw( classify classify_pair );

   # determine the type (e.g. HASH for a hashref) and the object class (if any)
   my ( $type, $class ) = classify( $some_scalar );


  # warn if two args differ, supply default if one is undef
  my $default_value =
    classify_pair( $arg1, $arg2 );

  # Also get type and class; error out if two args differ
  my ( $default_value, $type, $class ) =
    classify_pair( $arg1, $arg2, { mismatch_policy => 'error' });

  # If a given ref was undef, replace it with a default value
  classify_pair( $arg1, $arg2, { also_qualify => 1 });

DESCRIPTION

Scalar::Classify provides a routine named "classify" that can be used to examine a given argument to determine it's type and class (if any).

Here "type" means either the return from reftype (, or if it's a scalar, a code indicating whether it's a string or a number, and "class" it the object class, the way a reference has been blessed.

This module also provides the routine "classify_pair", which looks at a pair of variables intended to be of the same type, and if at least one of them is defined, uses that to get an appropriate default value for that type.

MOTIVATION

Perl contains a built-in "ref" function, and has some useful routines in the standard Scalar::Util library ('ref', 'looks_like_number') which can be used to examine the type of an argument. The classify routine provided here internally uses all three of these, returning a two-values that describe the kind of thing you're examining.

The immediate goal was to provide support routines for the Data::Math project.

EXPORT

None by default. Optionally:

classify

Example usage:

   my ( $type, $class ) = classify( $some_var );

Returns two pieces of information, the underlying "type", and the "class" (if this is a reference blessed into a class).

The type is most often (but not limited to) one of the following:

   ARRAY
   HASH
   :NUMBER:
   :STRING:

Other possibilities are the other potential returns from ref:

   CODE
   GLOB
   LVALUE
   FORMAT
   IO
   VSTRING
   Regexp

Internally, this uses the built-in function ref and the library functions reftype and looks_like_number (from Scalar::Util). The type is the return from "reftype" (e.g "ARRAY", "HASH") except that in the case of a simple scalar the type is a code to indicate whether it seems to be a number (":NUMBER:") or a string (":STRING:").

Note: if the argument is undefined, the returned type is undef.

classify_pair

Examines a pair of arguments that are intended to be processed in parallel and are expected to be of the same type:

If they're both defined, it checks that their types match. If at least one is defined, it generates a default of the same type by using the classify method. If both are undef, this default is also undef.

In scalar context, it returns just the default value.

In list context, it returns the default plus the type and the class (if it's a blessed reference).

An options hashref is accepted as a third argument, with allowed options:

 o  mismatch_policy

    If argument types mismatch, the behavior is determined by
    the mismatch_policy option, defaulting to 'warn'.
    The other allowed values are 'error' or 'silent'.

 o  also_qualify

    If the "also_qualify" option is set to a true value, then
    the given arguments may be modified in place: if one is
    undef, it will be assigned the determined default.

Examples:

  my $default_value =
    classify_pair( $arg1, $arg2, { mismatch_policy => 'error' });

  my ( $default_value, $type, $class ) =
    classify_pair( $arg1, $arg2, { mismatch_policy => 'error' });

  classify_pair( $arg1, $arg2, { also_qualify => 1 });

Note the slightly unusual polymorphic behavior: in scalar context returns *just* the default_value, in list context, returns up to three values, the default, the type and the class.

SEE ALSO

Params::Classify

This covers the argument checking case, where you want to verify that something of the correct type was passed. The perl5-porters are interested in adding core support for this module: it's fast and likely to get faster.

AUTHOR

Joseph Brenner, <doom@kzsu.stanford.edu>

COPYRIGHT AND LICENSE

Copyright (C) 2016 by Joseph Brenner

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

See http://dev.perl.org/licenses/ for more information.