$mysubs{name} = sub { 
   #subroutine implementation
};
 
...
 
$mysubs{name}->("call","args","whatever");
[download]

(untested)

another approach with a dedicated package

*MySubs::name = sub { 
   #subroutine implementation
};
 
...
 
# and later
MySubs::name("call","args","whatever");
 
# ... or ...
package MySubs; 
name("call","args","whatever");
[download]

(also untested)

TIMTOWTDI...

With this solution, how would my example code look like? Like this?

$mysubs{light}->(10);
$mysubs(light_at_time)->($timestamp);
[download]

I've already shown you three possibilities to call with "arguments".

I wouldn't try to load unknown subs into main-namespace, that can easily lead to errors.

Try and see what fits your needs.

Cheers Rolf

The keywords you are searching for here are 'partial function application' or 'currying'; both describe the practice of generating a new function with fewer arguments.

Continuing on LanX's answer, you can give the functions shorter names manually: my $light = $mysubs{'light'}; and then call them with $light->(10);

Anyway, if you want them installed to the symbol table, you can do this:

use strict;
use warnings;

my @sub_names = (qw/foo bar baz/);

foreach my $name ( @sub_names ) {
    no strict 'refs';
    *{__PACKAGE__ . "::" . $name} = sub {
        my ($parm) = @_;
        print "in $name (got $parm)\n";
    }
}

foo(42);
baz(10);
[download]

But be very careful about the content of @sub_names then. Standard cautions may apply, and using a hash is almost always better practice.

use feature ":5.14";
use warnings FATAL => qw(all);
use strict;
use Data::Dump qw(dump);

eval "sub $_ {say \"$_\"}" for qw(hello goodbye);
hello();
goodbye();
__END__
Produces:
hello
goodbye
[download]

More solutions, cool :-)

I see that lanX's answer is the "good" clean answer, but i don't like it as a stand-alone answer, as the code then looks ugly (i forgot to say it's a method, not a function) :

$S{light}->($self, 10);
[download]

instead of

$self->light(10)
[download]

(I used %S instead of %mysubs. And i use Moose, so i need to pass $self as an argument).

So, what i did was to use AUTOLOAD, to call these subroutines :

sub AUTOLOAD {
    my $self = shift;
    my @args = @_;

    # Retrieve the method name, without the Package name
    my $name = our $AUTOLOAD;
    $name    =~ s/.*://;

    # Check if this is one of the functions we declared
    croak "Undefined method : $name" 
        if !$S{$name};

    # Call the appropriate method
    return $S{$name}->($self, @args);
}
[download]

which enables me to call

$obj->light(10);
[download]

Now, the question is : is that clean, and are there "cleaner" (and why) solutions.

I must say i'm not in love with the 'eval' solution ( but it works :-) ).

Would it be cleaner to do

foreach my $name (@names) { 
    my $name = $S{$name};
}
[download]

But then i will also need to put $self as an argument all the time.

What about installing them in the import table : is it cleaner than using AUTOLOAD ?

With methods:

use feature ":5.14";
use warnings FATAL => qw(all);
use strict;
use Data::Dump qw(dump);

sub Mine()
 {package __SUB__;
  eval "sub $_ {say \"$_\"}" for qw(hello goodbye);
  bless {}
 }

my $a = Mine();
$a->hello();
$a->goodbye();
  
__END__
Produces:
hello
goodbye
[download]

There is a method to his madness. (Hamlet)

I've shown you two ways and the second works for objects too. (in perl package == class)

Don't know too much about moose.

But if you ask for "the cleanest" approach, better avoid metaprogramming!

Just define two getters and use a fat comma to get rid of the quoting.

$object->cell(light => 10);
$object->time(light => $timestamp);
[download]

I like metaprogramming, but here it's over the top.

And this certainly works with moose too!

Cheers Rolf

If it's a class, I would consider both the symbol table and the AUTOLOAD ways good; although AUTOLOAD is safer in the respect that it won't override any existing methods.

Personally, I'd just install the methods straight into the symbol table as it feels clean and should be slightly more performant. And safety -- you can avoid overwriting any subroutines at install time:

warn "baz already defined" if defined *{__PACKAGE__ . "::baz" };
[download]