Context and the Comma Operator

In A Tiny Code Quiz, Ovid posted this snippet of code inspired by Ben Tilly:

@ar1 = qw(foo bar);
@ar2 = qw(a b c d);
print scalar (@ar1, @ar2);

The answer jumped out at me, but that may be because I spent a lot of time documenting how context works in Perl. The book argues that there are two distinct contexts in Perl. Amount context governs how many items an expression expects (zero, one, or many) and type context governs the nature of data an expression expects (a true or false value, a number, unstructured data).

I know that it sounds like adding a post hoc formalism to a language deliberately designed to break the shackles of rigid mathematical thinking on programming language design and usability, but my thesis is that explaining how Perl works in terms of these two contexts helps people write better code because they're prepared to read and comprehend the documentation.

If you browse PerlMonks or, back when Usenet existed, comp.lang.perl.misc, you've probably heard the phrase "no such thing as a list in scalar context". That's one of the worst explanations to offer to a Perl novice, because it's simultaneously accurate and incomprehensible. What we should say instead is "the comma is an operator".

What's a Perl Operator?

In Perl, an operator is an action. It's a verb, if you're linguistically adept. It's not a variable, because it doesn't have data attached. It's not a value, because it doesn't change. (It's not a function or a method, because Perl's parser knows about it. It's a special kind of verb, a verb that Perl programs are born knowing. Take that, Sapir-Whorf and your thousand words for snowclones!) This seems counterintuitive, like arguing that the semicolon which separates expressions is an operator (even though good Haskell tutorials occasionally suggest that if they have really good explanations of monads). It seems wrong, but it's true.

Every Perl operator has several characteristics. These include arity (how many pieces of data it expects), precedence (when Perl should evaluate it with regard to other operators in an expression), associativity (whether it evaluates its data leftmost or rightmost), and its fixity (where it appears in an expression with regard to its data). All of those characteristics apply to the comma operator. When you write:

my ($rank, $rate) = ( 'Senior Consultant', '1000 septim per hour' );

... you expect the code to have the same effect as:

my $rank= 'Senior Consultant';
my $rate = '1000 septim per hour';

Even if you never thought about the comma as an operator, you probably expect that it separates expressions, appears between two operands, and operates left to right. If you've read Perl's precedence rules, you probably also expect that other operators get evaluated first. (That's why the parentheses are necessary.)

You may have never thought bout the context of the comma operator.

The Context of the Comma Operator

Some operators enforce context on their operands. scalar is a good example. You can't say what @array will evaluate to without knowing the surrounding context. When used as the first operand to push, Perl treats the array as a container and adds elements to it. When used as an argument to a (prototypeless) function, Perl extracts the elements of the array into a list. When evaluated in scalar context, you get the number of elements of the array.

(If you don't know much Perl, this may sound really complicated, but you have to learn a few things about fixity and arity and precedence in any language that isn't completely consistent about its representation form. Even Common Lisp has special rules for quoting that complicate things. If you want a programming language that people who don't know can read and instantly understand everything about what it's doing and why, you're going to be very disappointed when you turn off Star Trek and go outside.)

Other operators pass through their contexts. These operators include return and the comma operator. In other words, when Perl evaluates the operands of the comma operator, it does so with respect to the context in which it's evaluating the expression containing the comma operator.

In other words, in the expression:

my ($rank, $rate) = ( 'Senior Consultant', '1000 septim per hour' );

... the comma operator here is evaluated in list context because the lvalue of the assignment operator imposes list context (assigning to two variables), so the comma operator produces a list of two literal strings.

In the expression:

my $rate = ( 'Senior Consultant', '1000 septim per hour' );

... $rate gets the second literal, because the comma operator evalutes all of its operands and, in scalar context, evaluates to its right operand.

In the expression:

my @odds  = ( 1, 3, 5, 7,  9 );
my @evens = ( 2, 4, 6, 8, 10 );

my ($odd, $even) = ( @odds, @evens );

... $odd contains 1 and $even contains 3, because the comma operator evaluates in the list context imposed by the assignment to an lvalue list. The comma operator flattens its two operands into a list and the first two elements of that list—the first two elements of @odds—get assigned to the two lvalue variables.

In the expression:

my @odds  = ( 1, 3, 5, 7,  9     );
my @evens = ( 2, 4, 6, 8, 10, 12 );

my ($odd, $even) = scalar ( @odds, @evens );

... $odd contains 6 and $even remains undefined, because the comma operator evaluates its operands in the scalar context imposed by the scalar operator. In scalar context, of course, the two arrays each evaluate to the number of elements they contain.

Keep in mind, however, that the comma operator also has a behavior in scalar context. In scalar context, it evaluates to a single value, that of its right operand. The @evens array contains six elements, so that's what the comma expression evaluates to.

Understanding context helps—but the real problem is that most of us never think of the comma operator is an operator. Very few Perl tutorials and examples go into detail about how the parts of Perl fit together with regard to Perl's design philosophy of context, and very few really talk about what operators really are. When understand these concepts, the code example should make a lot of sense to you (even if you'd never write such a thing).

Modern Perl: The Book

cover image for Modern Perl: the book

The best Perl Programmers read Modern Perl: The Book.

sponsored by the How to Make a Smoothie guide



About this Entry

This page contains a single entry by chromatic published on November 17, 2013 6:00 AM.

Mojolicious Unicode Normalization Plugin Released was the previous entry in this blog.

The strict Pragma is a Cultural Marker is the next entry in this blog.

Find recent content on the main index or look in the archives to find all content.

Powered by the Perl programming language

what is programming?