Interpolation.pm
(Current version 0.73; last updated 13 June 2009)
Suppose your program needs to print out a lot of dollar amounts, and
you'd like to print each one out with a leading dollar sign, commas
every three places, and always two places for cents after a decimal
point, so that the number 1234.5 should be formatted as $1,234.50. One
way to do it is to define a commify routine to insert the punctuation
(which you can crib from the FAQ) and do something like this:
$com_SALARY = commify($SALARY);
print "Last year I made $com_SALARY.\n";
That can get old pretty quick---you end up with a lot of useless
variables like $com_SALARY cluttering up your program. Or you could
use printf:
printf "Last year I made %s.\n", commify($SALARY);
This is all right, but a little hard to read, because you have to
match up the formatting codes in the first argmuent with the values in
the rest of the arguments.
The bottom line here is that `commify' is just cosmetic, for output
formatting, not really an interesting or important part of the
program, and you'd really like to sweep it under the rug and make it
take up as little space as possible.
You can do that with Interpolation. Here's what that example looks
like if you use Interpolation:
print "Last year I made $money{$SALARY}.\n";
One line, no extra variables, and no sign of the formatting except the
descriptive word money there to say what the format is. If you're
going to be doing a lot of money, and the word money is too long, you
can use M instead:
print "Last year I made $M{$SALARY}.\n";
Or you can use whatever name you prefer, even _. If you're going to be
printing out a lot of percentages to two decimal places, you might
name the interpolator %, so that you could write this:
print "Sales have increased by $%{$increase}.\n";
And, since $% is an abbreviation for `format in a way appropriate for
percentages', what it would print would look like:
print "Sales have increased by 3.12%.\n";
You can have as many different formats as you want, and you can give
them whatever names you want. You can install a formatter in one part
of your program, and uninstall it again when you're done with it.
Here's another example: You do a database call and get back the name
of a U.S. state of Canadian province. The database doesn't capitalize
these consistently; sometimes they're correct, sometimes all
uppercase, sometimes all lowercase. You need to capitalize correctly
when you rpint out the results.
Rather than explicitly calling a capitalization function each and
every time you get data from the database, you can use an
interpolator, like this:
print "Database returned: $Cap{$RESULT}.\n";
$C is an interpolator that fixes the capitalization of anything it
gets, in this case the contents of $RESULT.
The argument to an interpolator can be any Perl expression. In the
context of the money example, that means you can do something like
this:
print "If I get a 6% raise, I'll be making $money{$SALARY * 1.06}.\n";
And again you save on space and on useless temporary variables. It
seems like this is prone to abuse, but in many cases, like this one,
it does seem to make the code clearer, putting emphasis on the
important parts and preventing a lot of excess verbiage that would
obscure what was really going on.
As a special case, you can evaluate arbitrary expressions into
strings, like this: "1 + 2 = $eval{1 + 2}", which turns into _1 + 2 =
3_.
See also:
Interpolation.pm page:
http://www.plover.com/~mjd/perl/Interpolation/
M-J. Dominus Perl Paraphernalia:
http://www.plover.com/~mjd/perl/
Jenda's page
http://Jenda.Krynicky.cz
