How to use block as a variable name in Perl - perl

Question

Guys I'm new to Perl and I am now in reference chapter, and this topic confuses me. I understand the concept of reference since I know C programming too. In the book I am reading says:
"Not only can you dereference a simple variable name, you can also dereference the contents of a BLOCK. Anywhere you'd put an alphanumeric identifier as part of a variable or subroutine name, you can replace the identifier with a BLOCK returning a reference of the correct type."
I need an example on this part- "anywhere you'd put an alphanumerc identifier as part of a variable.... you can replace the identifier with a block" - exactly how would that happen?
and this example too:
&{ $dispatch{$index} }(1, 2, 3);
Can somebody explain that code.

Answer 1

The quoted paragraph is saying that you're not limited to doing
my $handler = $displatch{$type} or die; # Arbitrary code
my $ref = $handler->(); # Arbitrary code
my #a = #$ref;
You can also do
my #a = #{ my $handler = $displatch{$type} or die; $handler->() };
Same goes for other dereferences.
$BLOCK
$BLOCK[ ... ]
$BLOCK{ ... }
#BLOCK
#BLOCK[ ... ]
#BLOCK{ ... }
%BLOCK
&BLOCK
&BLOCK( ... )
*BLOCK

Answer 2

$index contains the name of a hash key. %dispatch is the hash with said key. The value associated with that key is a subroutine reference, which &{} dereferences. It's invoked with 1, 2, 3 as its arguments.
This is a fine enough example, although I would generally write:
$dispatch{$index}->(1, 2, 3)

Answer 3

sub sample_function1 {
...
}
sub sample_function2 {
...
}
%dispatch = ( 'f1' => \&sample_function1,
'f2' => \&sample_function2 );
$index = <STDIN>;
chomp $index;
&{ $dispatch{$index} }(1, 2, 3);
If the user enters f1 this will call sample_function1(1, 2, 3), if he enters f2 it will call sample_function2(1, 2, 3).
What the documentation is explaining is that you since you can write sample_function1(1, 2, 3), you can replace the function name with a block containing code that returns a function reference.

Answer 4

Take a look at the File::Find. You may have even used that before. It's one of the first Perl modules that many Perl programmers ever use.
The find command takes two arguments:
The second (we'll start with the simple one) is a list of directories I want to search.
The first argument is a bit trickier -- it's an actual subroutine my find command will use. The find command uses that subroutine to determine if a particular element in my directory tree matches the criteria I'm looking for. What find does is go through each and every element of my directory tree and passes that element to my subroutine. It's up to my subroutine to check the element to see if it passes muster.
Let's say I want to find all files in my directory that have the suffix of .txt. In Unix, I could do this:
$ find $directory -type f -name "*.txt"
In Perl, I create a subroutine called wanted. The find command will pass to my wanted subroutine an element in my directory via the $_ Perl variable. I can then test that element to see if it's a file that has a .txt suffix:
sub wanted {
return unless -f; #Return unless $_ is a file
return unless /\.txt$/; #Return unless that file has a `.txt` suffix
print "$Find::File::name\n"; #It's a file that ends with .txt. Print it.
}
Now, all I have to do is get my wanted subroutine as the first parameter of my find command:
find ( \&wanted, $directory );
That's all there is to it. A real life example that you will (if you haven't already) run into really soon. In C programming parlance, the wanted subroutine would be called a Callback routine.