There is a vast difference between eval with a string and eval with a block. String-eval will evaluate the string, while block eval will execute the block and catch any exceptions raised in there. What you (seem to) want is the string form of eval:

use strict;
my $x = 3;
my $y = "2 * $x"; # interpolation here sets y to '2 * 3' already!
my $z = eval $y;  # $z is 6 now

print "\$x is $x";
print "\$y is $y";
print "\$z is $z";
[download]

More likely though, in the long run, you will want to ditch eval and build your own parser for mathematical expressions. There are two or three approaches to such parsers, the best documented way is the way Dominus describes in his book Higher Order Perl. The second approach would be to use Parse::RecDescent, which allows a "natural" approach to parsing but has horribly bad error messages whenever you mess up your input. The third approach is to use Parse::YAPP, which is mostly like the yacc compiler builder, but for Perl. I found yacc (and P:YAPP) to be unapproachable first, but the speed made up for the steeper learning curve.

Change your block eval (eval{$z}) to a string eval (eval $z)

my $x = 3;
my $y = "2 * $x";
my $z = eval {$y};

print '$z is: ', $z, "\n";
print 'eval of $z is: ', eval $z, "\n";
[download]

update: useless-use-of-quotes-noob-error eliminated. Yes, I should know better:(

It worked, thanks! If you have a moment, can you tell me what the difference between using {} and "" is? I'll look it up in perlfunc as well, but if you have any insight. Thanks a ton! Matt

The 'eval EXPR' version evaluates code at runtime like you expect while the 'eval BLOCK' version is used for exception handling (and is not evaluated at runtime).

For example normally DBI errors are fatal to the entire program. However, if I wrap my DBI calls in an eval BLOCK structure I can then catch a fatal DBI error and take steps to deal with that in my program such as logging it, restarting the database connection, etc. The important thing is that the fatal error doesn't take my script with it.

Personally I think using the same name is confusing. I would have preferred something like 'catch BLOCK' instead (or perhaps 'exception BLOCK').

Here's some 'eval BLOCK' code I use:

sub cmd_wrapper {
    my( $cmd ) = @_;
    my( $rc , $out );

    eval {
        local $SIG{ALRM} = sub { die "alarm\n" };
        alarm 15;
        $out = (`$cmd`)[0]; # Get first line of output
        $rc = $?;
        alarm 0;
        };

    if( $@ ) {
        die "Eval failed for $cmd but not because of alarm" if $@ ne "
+alarm\n"; # Propogate unexpected errors
        die "Eval failed for $cmd because alarm timed out";
        }

    die "Return code undefined for $cmd" unless defined $rc;
    return $rc, $out if wantarray;
    return $rc;
    }
[download]

See also Corion's post: Re: nested variable resolution.

eval explains it much better than I can. It's your first port of call if you're having problems with eval.

Have a look, and if you're still having problems, ask!

Take a look at Math::Expr. It stores math expressions as a parse tree object. You can store such objects in files with Data::Dumper.

Just use a (generally considered evil) string eval in both cases:

...

print '$z is: ', $z, "\n";
print 'eval of $z is: ', eval $z, "\n";
print 'eval of "2 * 3" is: ', eval '2 * 3', "\n";
[download]

Prints:

$z is: 2 * 3
eval of $z is: 6
eval of "2 * 3" is: 6
[download]