NAME

Perl::Compare - Runtime access to perl comparison operators

SYNOPSIS

use Perl::Compare qw(compare);
print compare('eq', 'abc', 'xyz') ? "True\n" : "False\n";
  
use Perl::Compare qw(sort_compare);
my @items = qw(The black cat climbed the green tree);
sort { &sort_compare('cmp', $a, $b) } @items;

EXPORTS

Nothing exported by default

Exported upon request: compare, sort_compare, sort_keydepth
:all: compare, sort_compare, sort_keydepth

DEPENDENCIES

This module requires these other modules and libraries:

Exporter

DESCRIPTION

Efficient routine to compare scalar values when the operator is variable. This is particularly useful for dynamic patterns, such as those read in from a configuration file, taken from an argument, or specified in a table somewhere.

Motivation

Efficiency and security, invoking eval (as eval or m//e) is not an option.

In some situations, the logic is more important than the function. Just like when you would use no warnings. For this reason these routines simply return the logical answer when values are undefined.

Basic functionality which can be extended. Okay, it's just nice to have some sugar some times. Extending this package with your own comparison routines should be straight foward. A few that we have added are:

mod       Modulo
bw        Stringwise begins-with
ew        Stringwise ends-with

Notes

Because one cannot pass modifiers to the regular expression engine, the following extensions were added:

=~i       Regular expression match, case insensitive
!~i       Regular expression does not match, case insensitive
eqic      Equal ignoring case
neic      Not equal ignoring case

PUBLIC INTERFACE

%COMPARISIONS

Comparison routines

The key is the comparison operator. The value is the subroutine which is executed.

If you wanted to define an operator named opr, you would:

Perl::Compare::COMPARISONS{'opr'} = sub {
  # your code here
};

Your comparison is invoked by:

compare('opr', 'a', 'b');

And your subroutine will be passed 'a' and 'b'. In fact, all arguments are passed, allowing you to write tertiary comparisons, such as:

compare('opr', 'a', 'b', 'c');

compare

Wrapper for Perl's internal comparison operators.

Support runtime comparison when the operator is held as a scalar.

Where $comparator may be one of:

&&        $a and $b are true vlaues
||        $a or $b is a true value
eq        Stringwise equal
ne        Stringwise not equal
lt        Stringwise less than
le        Stringwise less than or equal
gt        Stringwise greater than
ge        Stringwise greater than or equal
=~        Regular expression match
!~        Regular expression does not match
cmp       Stringwise less-than, equal-to, or greater-than
leg       Alias for cmp (see Perl 6)
==        Numeric equal
!=        Numeric not equal
<         Numeric less than
>         Numeric greater than
<=        Numeric less than or equal
>=        Numeric greater than or equal
<=>       Numeric less-than, equal-to, or greater-than
  
=~i       Regular expression match, case insensitive
!~i       Regular expression does not match, case insensitive
eqic      Equal ignoring case
neic      Not equal ignoring case
mod       Modulo
bw        Stringwise begins-with
ew        Stringwise ends-with

This example will return false:

compare('eq','',undef);