As in...

$a = "some ".$foo->bar." text";
[download]

Indeed. Or, in the (list) context of the original question, why would one want to bother even to understand  . (concatenation) or a crab when  , (comma) will do:
    warn "Put failed: ", $sftp->error, "\n";
(and it looks better, too, IMHO :).

---

Give a man a fish:  <%-{-{-{-<

Thanks all for the replies. So now I see 4 ways to do the same thing.

1. Baby cart

@{ $sftp->error }

2.crab

".$sftp->error."

3. reference, deference

${ \$sftp->error }

4. comma

", $sftp->error, "

Can someone explain how each of these work ?

Update: This was intended to be a reply to Re^6: Net::SFTP::Foreign error. Please disregard.

I assume you didn't understand the explanation given in the perlsecret link. Ok, so consider:

1. Baby Cart.   An array variable may be accessed using this "canonical" (in the sense that it always works) syntax:

   @{bareword     }
   @{symbolic reference  }
   @{hard reference   }

   (A symbolic reference — sometimes casually called a "soft" reference — only works with package-global variables as used in the example below. That's one reason symbolic references are Officially Frowned Upon; see symbolic references in perlref and also Why it's stupid to `use a variable as a variable name' and also the perlfaq7 FAQ "How can I use a variable as a variable name?" for others. Symbolic referencing also only works when  strict 'refs' are disabled.) The "baby cart" just goes one step further and uses an anonymous array constructor  [ ... ] to generate an array hard reference to be dereferenced. E.g.:

   c:\@Work\Perl\monks>perl -wMstrict -le
   "no strict 'refs';
    ;;
    our @array = qw(One Two Three);
    ;;
    my $soft_ref = 'array';
    my $hard_ref = \@array;
    ;;
    print @{ array }, '*', @{ $soft_ref }, '*', @{ $hard_ref };
    print qq/@{ array }-@{ $soft_ref }-@{ $hard_ref }/;
    ;;
    print qq/@{[ something_returning_a_list() ]}/;
    ;;
    sub something_returning_a_list { return qw(Nine Eight Seven); }
   "
   OneTwoThree*OneTwoThree*OneTwoThree
   One Two Three-One Two Three-One Two Three
   Nine Eight Seven
   [download]

2. Crab.   This is just string concatenation using the  . operator (see perlop). Scalars are stringized and concatenated together. Other data is handled in scalar context imposed by the concatenation operator. E.g.:

   c:\@Work\Perl\monks>perl -wMstrict -le
   "my ($x, $y, $z) = qw(Fie Foe Fum);
    my @ra = qw(foo bar baz);
    ;;
    my $s = $x . $y . $y . @ra;
    print $s;
   "
   FieFoeFoe3
   [download]

3. Reference, Deference.   The "canonical" syntax for scalar access is exactly orthogonal to that for arrays (or any other basic Perl data type):

   ${bareword     }
   ${symbolic reference  }
   ${hard reference   }

   The  ${ \$sftp->error } expression simply takes whatever scalar is returned by the method call to  $sftp->error and takes a hard reference to it. The hard reference is then dereferenced normally, and the resulting scalar value can be used like any other scalar, e.g., in string interpolation.
4. Comma.   The  , is just the comma operator (see perlop). In list context (as imposed, e.g., by the print built-in), it separates list items: scalars, arrays, epressions evaluating to scalars or arrays, etc. In
       warn "Put failed: ", $sftp->error, "\n";
   $sftp->error is just one more scalar item in the argument list fed to warn.
Which way is best? That's up to you and the circumstances you face.

---

Give a man a fish:  <%-{-{-{-<