#!/usr/bin/perl

use strict;
use warnings;

my $name = shift;

my $func = "update_$name";

main->$func(); # "main" should be the namespace the functions are in.

sub update_test { print "!test\n" }
sub update_hello { print "hello!\n" }
[download]

$ perl x.pl test
!test
$ perl x.pl hello
hello!
$ perl x.pl heheh
Can't locate object method "update_heheh" via package "main" at x.pl l
+ine 10.
[download]

#!/usr/bin/perl

use strict;
use warnings;

my $name = shift;

my %updates = (
               test => \&update_test,
               hello => \&update_hello,
              );
$updates{$name}->();

sub update_test { print "!test\n" }
sub update_hello { print "hello!\n" }
[download]

Wow. I have forgotten this already.

Globbing:

sub update_test{ print 'hi' };;

$n = 'test';;

*{'update_' . $n }->();;
hi
[download]

Thanks. It works! But I want to understand why it works.

Can you explain what is happening in this line?

*{'update_' . $n }->();
[download]


I thought glob is only used for directories.

See Globject sigils.

---

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.

Remember that perl allows you to have the same name for different things: $foo, @foo, %foo, and foo() (the subroutine 'foo') are all stored in different slots of the symbol table entry for the key 'foo': $foo is in SCALAR, @foo in ARRAY, %foo in HASH, and foo() in the CODE slot. We reference all of these things at once via a "glob".

The string inside the curlies is the key we'll use to access the symbol table.

The *{...} (the glob reference syntax) is essentially saying "find the symbol table entry that contains references to all the things with this name".

The ->() following the dereference says "call what the CODE slot references in this entry." It the sub had arguments, you could put them in the parens.

Thanks. It works! But I want to understand why it works. Can you explain what is happening in this line? *{'update_' . $n }->(); download I thought glob is only used for directories.

The glob() function is used to search for files.

On the other hand, perl has many different types: scalars, arrays, hashes, etc. And a perl program can happily have variables named $x, @x, and %x, and it will run without error. A typeglob is one of the types in perl. The typeglob *x represents all variables named 'x' in your program, e.g. $x, @x, %x, sub x {}, etc. In order to understand typeglobs, you need to read perlreftut first, so that you know what references are.

The code fragment:

*{'update_' . $n }
[download]

resolves to the typeglob: *update_test. The arrow following the brackets:

*{'update_' . $n }->
[download]

*{'update_' . $n }->()
[download]

In this case, the left side of the arrow, i.e. the typeglob, is treated as a reference to a subroutine, and the subroutine is called. Compare to this:

#####use strict;
use warnings;
use 5.010;

sub greet {
    my $greeting = shift;
    say $greeting;
}

%greet = (
    a => 'hello',
    b => 'goodbye',
);


my $code_ref = \&greet;
$code_ref->('hello');

my $hash_ref = \%greet;
say $hash_ref->{b};

*greet->('goodbye');
say *greet->{a};


--output:--
hello
goodbye
goodbye
hello
[download]

my %dispatch = (
    test   => sub { print "test\n"  },
    hello  => sub { print "hello\n" },
);

my $name = 'test';
$dispatch{$name}->();

$name = 'hello';
$dispatch{$name}->();
[download]

In the event I actually want the symbol table (I can't actually recall wanting this, outside of calling methods...) then I tend to prefer can(). It does have caveats: if you're dealing with a class, it will search up the inheritance tree. However, this is usually something I want.

my $name = 'test';
__PACKAGE__->can("update_$name")->();

$name = 'hello';
__PACKAGE__->can("update_$name")->();

sub update_test  { print "test\n"  }
sub update_hello { print "hello\n" }
[download]

I can't find any documentation for the can() function. Link?

perldoc UNIVERSAL

Essentially it's a method inherited by every class.

use strict;
[download]

Can't use string ("update_test") as a symbol ref while "strict refs"
[download]

Then use:

my $result = do{ 
    no strict 'refs'; 
    *{ 'update_' . $n }->() 
};;
hi
[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.