From perlop

       Unary "+" has no effect whatsoever, even on strings.  It is use
+ful
       syntactically for separating a function name from a parenthesiz
+ed
       expression that would otherwise be interpreted as the complete 
+list of
       function arguments.  (See examples above under "Terms and List
       Operators (Leftward)".)
[download]

#!/usr/bin/perl -w
use warnings;
use strict;

# --------------------
#  force context
# --------------------
sub VOID (&) {
  print "VOID:\t";
  $_[0]->();
  return;
}

sub LIST (&) {
  print "LIST:\t";
  () = $_[0]->();
  return;
}

sub SCALAR (&) {
  print "SCALAR:\t";
  scalar $_[0]->();
  return;
}

# --------------------
# tests
# --------------------

sub ctxt {
   unless (defined wantarray) {
      print "is void\n";
   } elsif (wantarray) {
      print "is list\n";
   } else {
      print "is scalar\n";
   }
}

SCALAR { ctxt };
SCALAR { +(ctxt) };           # u+ no effect

LIST { ctxt };
LIST { +(ctxt) };             # u+ no effect

VOID { ctxt };
VOID { +(ctxt) };;            # u+ no effect

#  BUT

LIST { 0+(ctxt) };            # forcing scalar context
[download]

SCALAR:    is scalar
SCALAR:    is scalar
LIST:    is list
LIST:    is list
VOID:    is void
VOID:    is void
LIST:    is scalar
[download]

(code stolen from older post)

Shorter alternative:

>perl -MO=Concise,-exec -e"$a = +f()" 2>&1 | find "entersub"
5  <1> entersub[t3] sKS/TARG

>perl -MO=Concise,-exec -e"@a = +f()" 2>&1 | find "entersub"
6  <1> entersub[t4] lKS/TARG

>perl -MO=Concise,-exec -e"+f()" 2>&1 | find "entersub"
5  <1> entersub[t2] vKS/TARG
[download]

The first letter of the "word" after the op name (entersub) is the context in which it's evaluated.

Interesting!

> Shorter alternative:

Well ...

the sub ctxt() is just using the well documented wantarray the rest is only cosmetics to provide readable output.

If I wanted to golf, I could also do:

>perl -E"sub f{say qw/s l v/[wantarray//'2']};+f;$a=+f;@a=+f"
v
s
l
[download]

Cheers Rolf
_{(addicted to the Perl Programming Language :)
Wikisyntax for the Monastery FootballPerl is like chess, only without the dice}

hmm me too.

My theory is that the scalar aassign in the concise output returns a modifiable value, but that the compiler "forgot" to moan here.

That's probably an implementation detail that might change in the future and break this code.

C:\>perl -e "@a=1..5; print 0+( @a );"
5
C:\>perl -e "@a=1..5; print --( @a);"
Can't modify array dereference in predecrement (--) at -e line 1, near
+ ");"
Execution of -e aborted due to compilation errors.

C:\>perl -MO=Concise -e "print --( () = /;/g );"
a  <@> leave[1 ref] vKP/REFC ->(end)
1     <0> enter ->2
2     <;> nextstate(main 1 -e:1) v:{ ->3
9     <@> print vK ->a
3        <0> pushmark s ->4
8        <1> predec sK/1 ->9
7           <2> aassign[t1] sKPRMS ->8
-              <1> ex-list lK ->6
4                 <0> pushmark s ->5
5                 </> match(/";"/) l/RTIME ->6
-              <1> ex-list lK ->7
6                 <0> pushmark s ->7
-                 <0> stub lPRM* ->-
-e syntax OK
[download]

print "".( () = /;/g );  #prints "3"
[download]

why not just?:

print tr/;//;
[download]

0+ would make more sense than "". here.

fair enough, both work.

As an update, string concatenation can be used in other situations to force scalar context so it is valid to mention that possibility. In this particular case, 0+ is perfect. However if the goal is only to count ";", tr is even better.

Interesting (I expected a compilation error here, similar as with number predecrement, e.g. --5):

A numeric literal doesn't return an lvalue, but an assignment in scalar context returns an lvalue. See Mini-Tutorial: Scalar vs List Assignment Operator.