What you're employing is the Ternary operator which has the form:

   $variable = <condition> ? <value1> : <value2>;
[download]

The variable gets set to value1 if the condition resolves to true, or value2 if the condition resolves to false. So you should not be using "say" in either the value1 or value2 positions as you do in your example. So lets rewrite it without the say:

   my $c = <true/false> ?  "$c found!" : "None!";
[download]

And now the problem is clear, in the true case, you're trying to initialize $c to a value that contains _itself_. It's like saying my $c = $c, it's nonsensical.

Thanks to both of you for the clarity! For far too long I've thought of the ternary operator as, well, not an operator, but a concise shorthand for if/else. Perfectly and quickly answered; thanks for sharing the wisdom!

I'm guessing that's a mocked up example derived from some "real" code because as it stands it doesn't make sense on a bunch of levels.

1/ say doesn't return much that's useful (true on success, but printing to the console wil pretty much always succeed). Both invocations of say will return the same result so $c gets the same value regardless.

2/ Maybe what you really wanted was to say $c, not the contents of $c. In that case you should either have written "\$c ..." or '$c ...'.

3/ We don't usually use & in function calls now, just write func().

To better understand how Perl parses your code, run:

perl -MO=Deparse,-p yourscript.pl
[download]

my($c);
($c = (&func() ? say("$c found!") : say('None!')));
[download]

See also: Surprised by Perl parse of ternary operator.

Because thats how its supposed to work :) strict, diagnostics, splain...the spirit of strict ...

 $ perl -e " use diagnostics; my $c = $c; "
Name "main::c" used only once: possible typo at -e line 1 (#1)
    (W once) Typographical errors often show up as unique variable nam
+es.
    If you had a good reason for having a unique name, then just menti
+on it
    again somehow to suppress the message.  The our declaration is
    provided for this purpose.

    NOTE: This warning detects symbols that have been used only once s
+o $c, @c,
    %c, *c, &c, sub c{}, c(), and c (the filehandle or format) are con
+sidered
    the same; if a program uses $c only once but also uses any of the 
+others it
    will not trigger this warning.
[download]

The $c on the right side of my $c = is the global variable $main::c, and $main::c is not the same as $c

Also

$ perl -e " use diagnostics; my $c = $c; my $c = $c; "
"my" variable $c masks earlier declaration in same scope at -e line 1 
+(#1)
    (W misc) A "my", "our" or "state" variable has been redeclared in 
+the
    current scope or statement, effectively eliminating all access to 
+the
    previous instance.  This is almost always a typographical error.  
+Note
    that the earlier variable will still exist until the end of the sc
+ope
    or until all closure referents to it are destroyed.

Name "main::c" used only once: possible typo at -e line 1 (#2)
    (W once) Typographical errors often show up as unique variable nam
+es.
    If you had a good reason for having a unique name, then just menti
+on it
    again somehow to suppress the message.  The our declaration is
    provided for this purpose.

    NOTE: This warning detects symbols that have been used only once s
+o $c, @c,
    %c, *c, &c, sub c{}, c(), and c (the filehandle or format) are con
+sidered
    the same; if a program uses $c only once but also uses any of the 
+others it
    will not trigger this warning.
[download]

So its  my $c = $main::c;  my $c = $c; and the second lexical $c takes places of the original lexical $c (my $c) ... so the first my $c is invisible

my $c = ...
[download]

There is also a possible precedence issue with your statement. If you meant:

$c = &func();
$c ? say "$c found!" : say "None!";
[download]

$c = (&func() ? say "$c found!" : say "None!");
[download]

perl -Mstrict -E 'sub func {5}; my $c; my $results = ( $c=func() ? 1 :
+ 2); say $c, "\t", $results'
[download]

perl -Mstrict -E 'sub func {5}; my $c; my $results = ( $c=func()) ? 1 
+: 2; say $c, "\t", $results'
[download]

You say, re your second code block, "Works just fine."

That's interesting. My milage varies:

C:\>perl -E "use 5.018; use strict; my $c; $c = &func() ? say '$c foun
+d!' : say 'None!';"
Undefined subroutine &main::func called at -e line 1.
[download]

... but...

C:\>perl -E "use 5.018; use strict; sub func {say 'in func()';}my $c; 
+$c = &func() ? say '$c found!' : say 'None!';"
in func()
$c found!
[download]

Aside from returning the declaration of $c to the one liner and the variant quoting, I see no diffs. Can you explain?

The original post quite possibly did not contain the full code. Maybe the func subroutine is defined somewhere else.

my $c = &func() ? say "$c found!" : say "None!";
[download]

my $c = ( &func() ? say "$c found!" : say "None!" );
[download]

Neither my $c nor the assignment has been evaluated when you tried to read $c. You meant

( my $c = &func() ) ? say "$c found!" : say "None!";
[download]

Fixing that error won't fix the error you see, though. Lexical variables only become visible the statement after the one in which they are created in order to allow the following to work.

my $x = 123;
{
   my $x = $x;
   say $x;   # 123
   $x = 456;
   say $x;   # 456
}
say $x;   # 123
[download]

Anyway,

my $c = func();
say $c ? "$c found!" : "None!";
[download]

say( ( my $c = func() ) ? "$c found!" : "None!" );
[download]

Reason for this is to be able to write something like  my $x=$x+1