Be aware that most Perl experts discourage the use of string eval. For example:

• merlyn in •Re^2: Dynamically constructed function calls states: Do not resort to eval-string if other means are available. You're firing up the compiler (slower than almost any other solution), and exposing yourself to hard to debug and hard to secure practices.
• In this quiz of the week MJD states: A good rule of thumb is that unless what you're trying to do is most clearly described as "compile and run arbitrary Perl code", it's probably a mistake to use 'eval' to do it.
• Perl Best Practices, Chapter 8, has a guideline titled: Avoid string eval. Conway argues that string eval can be slow; produces run time warnings rather than more desirable compile time warnings; and code that generates other code tends to be harder to maintain.

While string eval should be avoided, block eval (spelled try with perl 5.40+) is fine, as described here.

References Added Later

• Re^3: Create sort function from a text file (string eval vs block eval) by me (2021)

• The safety of string eval and block eval. by TrixieTang (2016)
• Re^4: The safety of string eval and block eval. by afoken (2016)
• Undumping Perl by haukex (2016)

• Loading PERL Module from scalar in RAM? by AssetXero (2023)

• trouble with packages/eval/variable-scoping by Ratazong (2024)
• Re: trouble with packages/eval/variable-scoping by afoken (2024) - Imagine someone changing xxx.ptysav to contain $_=`rm -rf /`;. That would be a bad day for you.
• Re^3: trouble with packages/eval/variable-scoping by hippo (2024) - Config files should be parsed, not executed
• Re^2: passing newline in string argument by haukex (2025) - "I think it's very well worth mentioning that eval is a massive security hole with untrusted input"

See Also

• Re: eval to replace die? (Exceptions and Error Handling References)

my %op_table = (
    le => sub { $_[0] <= $_[1] },
    ge => sub { $_[0] >= $_[1] },

    # etc.
    );

exists $op_table{ $op } or die "The operator '$op' does not exist.\n";

if ( $op_table{ $op }->( $a, $b ) ) {
    do something
    }
else {
    do something else
    }
[download]

I ended up implementing it using your hash. I was thinking about doing eval and string comparison, but this would not work for cases like comparing 5 le 14. Also, not using eval save me from firing another process

String eval doesn't launch another process. It merely runs the compiler again.

Bah, if you have to use a hash anyway, eval doesn't help any.

my %perlop = (
   lte => sub { $_[0] <= $_[1] },
   gte => sub { $_[0] >= $_[1] },
   # ...
);

my $r = $perlop{$op}->($a, $b);
[download]

(Oops, seems I had the page opened a while without realising it, and others have already answered this since then.)

Is it possible to do $r = eval("$a $op $b")

In principle yes, if you map the operators 'le', 'ge' etc. to the corresponding Perl equivalents — e.g. using a hash.

my %perlop = (
   le => '<=',
   ge => '>=',
   #...
);

my $r = eval "$a $perlop{$op} $b";
[download]

(But as always with string eval, be careful what you interpolate when the data ($a, $b here) doesn't come from trusted sources...)

(But as always with string eval, be careful what you interpolate when the data doesn't come from trusted sources...)

If you whitelist allowed operators via hash, and don't interpolate $a and $b, you should be fine:

if (exists $perlop{$op}) {
    my $r = eval "\$a $perlop{$op} \$b";
} else {
    die "OH NOEZ!";
}
[download]

That way the string passed to eval contains the variable names, and obtains their value from the outer scope.

Perl 6 - second systems done right

I just don’t like “clever solutions” anymore.   The strategy that always seems to work best, at least for yours truly, is to find the simplest and most-obvious way to write code that expresses what you truly mean to say.   Then, let the mighty Perl interpreter do the rest.   After all, microprocessors are never going to slow down anytime soon.   They’ll only become faster.   But software maintenance and development costs will only increase.   And it will be the “clever” solutions, i.e. “the ones that surely must have mightily impressed the programmer himself,” that will bite you in the a*s first.   (Usually at three o’clock in the morning.)

I guess I was looking for a cleaner solution than a more clever solution. With the hash, I was able to cut out 100 lines of repeated code and I can easily add addition operation using the hash. But I agree with you, I rather read longer code that is self explanatory than a bunch of clever hacks string together