• The do uses twice as much memory.
• The second uses a global variable (*FILE{IO}) without localizing it.

Cleaned up (with do ⇒ elegant):

my $raw = do {
   open(my $fh, '<', $file)
      or die("Could not read file: $!\n");
   binmode $fh;
   local $/;
   <$fh>
};
[download]

Cleaned up (without do ⇒ saves memory):

my $raw;
{
   open(my $fh, '<', $file)
      or die("Could not read file: $!\n");
   binmode $fh;
   local $/;
   $raw = <$fh>;
}
[download]

There's a simple solution to the memory doubling problem:

my $raw = do {
   open(my $fh, '<', $file)
      or die("Could not read file: $!\n");
   binmode $fh;
   local $/;
   \<$fh>
};

$$raw =~ ...; ## etc.
[download]

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

"Too many [] have been sedated by an oppressive environment of political correctness and risk aversion."

Do you care to explain why does the do version uses 2x as much memory?
[]s, HTH, Massa (κς,πμ,πλ)

No can do. I don't know why.

Update: Actually, it's quite basic. The assignment of do's return value causes it to be copied. You'll notice the same effect from subroutines.

use Devel::Peek qw( Dump );

{
   my $x = do {
      my $y = 'abcdef';
      Dump($y);
      $y
   };
   Dump($x);
}

{
   my $x = sub {
      my $y = 'abcdef';
      Dump($y);
      $y
   }->();
   Dump($x);
}

__END__
SV = PV(0x226df4) at 0x226ce0
  REFCNT = 1
  FLAGS = (PADBUSY,PADMY,POK,pPOK)
  PV = 0x1822b04 "abcdef"\0
  CUR = 6
  LEN = 8
SV = PV(0x226e24) at 0x226d34
  REFCNT = 1
  FLAGS = (PADBUSY,PADMY,POK,pPOK)
  PV = 0x187a93c "abcdef"\0           <-- new buffer
  CUR = 6
  LEN = 8
SV = PV(0x226e0c) at 0x1830320
  REFCNT = 1
  FLAGS = (PADBUSY,PADMY,POK,pPOK)
  PV = 0x182c84c "abcdef"\0
  CUR = 6
  LEN = 8
SV = PV(0x226e60) at 0x226d70
  REFCNT = 1
  FLAGS = (PADBUSY,PADMY,POK,pPOK)
  PV = 0x1855fac "abcdef"\0           <-- new buffer
  CUR = 6
  LEN = 8
[download]

I'd think that do block creates an anonymous lexical variable to hold the last value, and its content is being copies to the caller.

Try to measure the memory for returning something like [ <$handle> ], if my theory holds it won't use twice as much memory then because only the array reference is copied.

Update: I second the others who also recommend to use a lexical for the file handle.

open my $file, "<", $file or die "crap: $!";
my $raw = do { local $/; <$file> }; # sexy
close $file;
[download]

Personally, my favorite slurping method these days is slurp() from File::Slurp. It's up to version 9_999.x, so you know it's good.

Thus the second form is recommend (better even with a lexical variable as the file handle).

Another way to do it:

open my $FILE, '<:raw', $file or die "could not open $file: $!";
-s $FILE == read $FILE, my $raw, -s $FILE or die "could not read $file
+: $!";;
close $FILE;
[download]

There are two optimizations that can prevent it; one is that a number of different operations that normally use a targ switch to using an arbitrary scalar when their result is being assigned to it by scalar assignment. Compare the direct assignment vs. the assignment with an intermediary operation:

$ perl -MO=Concise,-exec -we'my $foo = scalar <STDIN>'
1  <0> enter 
2  <;> nextstate(main 1 -e:1) v
3  <#> gv[*STDIN] s
4  <1> readline[t3] sK/1
5  <0> padsv[$foo:1,2] sRM*/LVINTRO
6  <2> sassign vKS/2
7  <@> leave[1 ref] vKP/REFC
-e syntax OK
~$ perl -MO=Concise,-exec -we'my $foo = <STDIN>'
1  <0> enter 
2  <;> nextstate(main 1 -e:1) v
3  <0> padsv[$foo:1,2] sRM*/LVINTRO
4  <#> gv[*STDIN] s
5  <1> readline[t3] sKS/1
6  <@> leave[1 ref] vKP/REFC
-e syntax OK
[download]

The other optimization that prevents readline from using its targ is specific to readline. When you catenate onto a buffer, the readline and concatenation operations are joined into a single rcatline operation:

$ perl -MO=Concise,-exec -we' $foo.=<STDIN>'
Name "main::foo" used only once: possible typo at -e line 1.
1  <0> enter 
2  <;> nextstate(main 1 -e:1) v
3  <#> gvsv[*foo] s
4  <#> rcatline[*STDIN] sS
5  <@> leave[1 ref] vKP/REFC
-e syntax OK
[download]

my $raw = slurp_file( $file);

sub slurp_file {
    return do {
        local ( *ARGV, $/, $^I );
        use open qw' IN :bytes ';
        @ARGV = @_;
        <>;
    };
}
[download]