I was pretty sure I had a handle on circumfix–I had rightly guessed the “around” connotation of the “circum-” prefix. It was “postcircumfix” that threw me off the scent, though. I was left thinking “Wait, if it’s ‘around’, how can it also be ‘after’?” After all, there isn’t a “precircumfix” or “incircumfix”. :-)

So, with a postcircumfix operator, is the item that comes before also an argument to the operator? For example, given “@bar[1, 2, 3]“, is @bar also an argument to :postcircumfix<[]> ?

(Here’s hoping my angle brackets didn’t get mangled, and that I didn’t goof the syntax too badly… Perl 6 syntax is rather notably different from Perl 5 in ways that still occasionally elude me.)

The parentheses construct a Signature object which latches onto the routine. Having the ‘–> RetType’ inside of the parentheses means that it’s clearer that the return type forms a part of the Signature, and can be introspected along with the parameters.

On the other hand, pointy blocks (see S06) show that Perl 6 sometimes employs syntax where things which are semantically ‘inside’ an object are syntactically placed outside that object. So I guess that’s not really a defendable reason.

Starting from another angle, the Signature can be seen as a contract with the caller, essentially promising “if you give me $a, $b and $c of some specified types, I will return RetType (if and when I return normally)”. Seen as a contract, the Signature may as well keep the return type, representing the part of the bargain that the routine has promised to uphold.

A third aspect of this, again speaking in your favour, is that Signatures are used as the LHS of list assignments in Perl 6. (A generalization which excites and surprises me.) In this case, I have no idea what a return type might mean; applying the argument from ignorance gives that it shouldn’t be there in the first place. :)

But I do wonder what is the rationale for having “–> RetType” inside the parentheses, it seems rather counter-intuitive to me to mix it with the parameters declaration. OTOH maybe it’s again my C++ background getting through as C++0x now allows either

RetType foo(T a, U b);

or

[] foo(T a, U b) -> RetType;

which is similar to Perl6 way.

But specifying the return type inside of the signature is perfectly OK too: sub foo($a, $b, $c --> RetType) { ... }.

Note the two dashes in the arrow, by the way.

“Postcircumfix” also surround things, but besides doing that, they also come after something else. Again, parentheses and brackets are a good example. :) The parentheses in ‘(1, 2, 3)’ work differently than the parentheses in ‘foo(1, 2, 3)’, because the latter are a postcircumfix. Ditto ‘[1, 2, 3]‘ and ‘@bar[1, 2, 3]‘.

The parser in Perl 6 works in such a way that it’s never confused about whether it expects a circumfix or a postcircumfix. The ‘tax’ we as users pay for that is that we have to make sure we get the whitespace right. Specifically, there must be no whitespace between a postcircumfix operator and the thing that precedes it. So ‘say(1, 2, 3)’ and ‘say (1, 2, 3)’ mean “print three things” and “print one thing”, respectively. For the rare cases when you really want to separate things and still have a postcircumfix, there’s something called an ‘unspace’: a backslash followed by any amount of whitespace, like this: ‘say\ (1, 2, 3)’.