I'd say it's just code references, documented in perlref. See also Function object and "First-class functions" on Rosettacode, which have Perl and Python examples. %dispatch is a Dispatch table (and you probably meant to write the code references as foo => \&somefunc). I'm far from a Python expert, but AFAICT, these pieces of code should be pretty much equivalent:

#!/usr/bin/env perl
use warnings;
use strict;

sub somefunc { print "Hello, $_[0]\n" }

my %dispatch = (
    foo => \&somefunc,
    bar => sub { print "World$_[0]\n" },
);

$dispatch{foo}->("Perl");
$dispatch{bar}->("!");
[download]

#!/usr/bin/env python3

def somefunc(x):
    print("Hello, "+x)

dispatch = {
    'foo': somefunc,
    'bar': lambda x: print("World"+x),
}

dispatch["foo"]("Perl")
dispatch["bar"]("!")
[download]

Note however that using a string as a reference is a symbolic reference and is generally discouraged (and generally not possible under strict): Why it's stupid to `use a variable as a variable name'. Usually it's better to use a hash instead, like the above %dispatch. Update: And your second example is probably better written as my $funcname = ( $someCondition ? \&foo : \&bar );

Note that 'symbolic names' work perfectly fine as 'method names' under strict and warnings :)

#!/usr/bin/perl

# https://perlmonks.org/?node_id=1232013

use strict;
use warnings;

my $someCondition = 0;
my $arg1 = 'arg1';
my $arg2 = 'arg2';

my $funcname = ( $someCondition ? 'foo' : 'bar' );
SomeClass->$funcname($arg1, $arg2);

package SomeClass;

sub foo { print "in 'foo' with args: @_\n" }

sub bar { print "in 'bar' with args: @_\n" }
[download]

That's a symbolic reference, which is not allowed under strict:

perl -E "use strict; use warnings; sub hello { say 'Hi' }; my $sub = '
+hello'; $sub->()"
Can't use string ("hello") as a subroutine ref while "strict refs" in 
+use at -e line 1.
[download]

It's technically the dereference of a symbolic reference that's not allowed. However, there is a (documented) exception:

\&$sub_name
[download]

This means that while

$sub_name->()
[download]

isn't allowed,

(\&$sub_name)->()
[download]

is allowed.

($invocant->$method_name() is also allowed under strict.)

It's technically the dereference of a symbolic reference that's not allowed.

Is there another case where you would call a variable a symbolic reference when it's not being dereferenced? With eval or when accessing a value through the symbols table?

You're right about those two exceptions, at least the exceptions are complex enough that beginners shouldn't use them by accident.

> However, there is an exception:

More there are:

use strict;
use warnings;


sub tst {
    warn "tst($_[0]) called\n"
}

my $symbol="tst";


($::{$symbol})->(1);

&{$::{$symbol}}(2);

(main->can($symbol))->(3);

&{main->can($symbol)}(4);
[download]

C:/Perl_524/bin\perl.exe  d:/exp/symbolic_references.pl 
tst(1) called
tst(2) called
tst(3) called
tst(4) called
[download]

NB:

• $::{...} is a shortcut for STASH lookup $main::{...} and returns a type-glob
• ->can(...) returns a coderef

  Cheers Rolf
  _{(addicted to the Perl Programming Language :)
  Wikisyntax for the Monastery FootballPerl is like chess, only without the dice}

Here is another exception, no complaints:

use strict;
use warnings;
sub asub { print "heee\n"; }

my $x = 'asub';
main->$x();
[download]

bw, bliako

Not really an exception IMHO because asub is a "method" of the main class/package, so the  -> invocant works as documented.

---

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

my $funcname = ( $someCondition ? 'foo' : 'bar' );
$someObject->$funcname($arg1, $arg2);
[download]

That's OK, from examples above:

use strict;
use warnings;

package Object;
sub new { return bless \{} }
sub foo { printf "hello foo = %s\n", ( caller(0) )[3]; }
sub bar { printf "hello bar = %s\n", ( caller(0) )[3]; }

package main;

my $someObject    = Object->new();

my $someCondition = 0;
my $funcname      = ( $someCondition ? 'foo' : 'bar' );
$someObject->$funcname($funcname);

$someCondition = 1;
$funcname = ( $someCondition ? 'foo' : 'bar' );
$someObject->$funcname($funcname);
[download]

The code has use strict; use warnings; in it and I don't recall it failing its tests, so now, not only do I have to admit to the Pythonista that I did a Bad Perl Thing, I have to figure out why the code coverage is bad.

The heck with it. I ain't admitting nothing. I've already coded my way out of it because the two conditions I was dealing with need distinct messages so I am just going to use an if/else and move on.

Thank you, all.

my $func_name = ( $someCondition ? 'foo' : 'bar' );
my $func_ref = __PACKAGE__->can($func_name);            # or other pac
+kage
$func_ref->($arg1, $arg2);
[download]

I'm sure there is a similar method like can() in Python too.

> What is the name of the idiom

When talking to non-Perlers I'd use the general term "introspection"

Update:

->can is also strict and more stable, since you can easily catch missing subs.

It won't work with AUTOLOAD though

No, you shouldn't. can performs a method lookup, not a sub lookup.

As for not working with AUTOLOAD, that would indicate a bug in the class using AUTOLOAD. It should override can to provide a meaningful result.

> No, you shouldn't. can performs a method lookup, not a sub lookup.

->can does a sub lookup if @ISA is empty, and the content of @ISA is introspectable too.

And using a package for a module and a class is a pretty dubious concept.

Cheers Rolf
_{(addicted to the Perl Programming Language :)
Wikisyntax for the Monastery FootballPerl is like chess, only without the dice}

"I made the 'mistake'..."

It looks you did your pythonistic inquisitor a favor - with the result of yet another jesuitic debate here on PM 😎

"I'm a simple man" B.B. King (1925-2015)

May i ask what the hell is wrong with your dispatch table solution?

Best regards, Karl