%func = {
    Click => {
        func => \&compute,
        param => [ @param ] },
    Click2 => {
        func => \&compute2,
        param => [ @param2 ] },
};
[download]

----------
[download]

update: How to set a parameter:

How to call a function:

update: corrected @{} in func call

----------
[download]

There are many more ways to do it.

Also:

    ...
    Click => {
        func => \&compute,
        param => \@param },
    ...
[download]

Or:

    ...
    Click => [ \&compute, \@param ],
    ...
[download]

use strict;

my %dispatch = (
   foo => [\&foo,qw(5 * 4)],
   bar => [\&bar,'HELLO'],
);

for (keys %dispatch) {
   my ($sub,@args) = @{$dispatch{$_}};
   print $sub->(@args),"\n";
}

sub foo {
   my ($n1,$op,$n2) = @_;
   return eval "$n1 $op $n2";
}

sub bar {
   return ucfirst lc shift;
}
[download]

jeffa

L-LL-L--L-LL-L--L-LL-L--
-R--R-RR-R--R-RR-R--R-RR
B--B--B--B--B--B--B--B--
H---H---H---H---H---H---
(the triplet paradiddle with high-hat)

Surely using positional parameters causes serious braindamage :-)

A solution could be using named parameters (a hash, I mean). For example, parameters for ClickInterval and Exposure could be respectively:

%param = ( firstClick => 12345, secondClick => 21345) ;
[download]

and

%param = ( 'value' => 911 ) ; # call for help on "Exposure"
[download]

Once you compose the %param hash someway, you could end up your code with a simple call:

my @res = $function_etc_etc{$a_function}->(%params) ;
[download]

and each sub will get only the parameters it deserves :-)

Ciao!
--bronto

# Another Perl edition of a song:
# The End, by The Beatles
END {
  $you->take($love) eq $you->made($love) ;
}

thanx a lot for your replies but I still fail to understand how to pass the args.... oki I'll re read the node

YES i understand that. however, what would be really nice, is if I could build a dispatch table for the parameters as well, and then give a value to the params somewhere in my code and then use it whenever I please. don't know if I clear

fglock your solution still isn't quite like what I imagined : imaghine I have 3 parameters $toto, $titi, $tata.
I'm inside a while(){} and I want to call some funcs of my dispatch table with either $toto, $titi, or $tata ( depending of the type of data i'm fed) but keeping in mind that the values of $titi, $toto, $tata change at every iteration (because of the data i'm fed) ..... is it possible?

In fact what I currently do is kinda the same as you suiggest, but i have to pass around in a hash of 15 arguments ( and then the subs figure out wich ones they need ) so it's kinda a waste, which is why I want to refine this mechanism

my %dispatcher = ( 
  foo => compute_interval($titi), 
  bar => compute_interstice($tata), 
  baz => compute_inact_and_expo_effective($toto),
  qux => get_exposure_service($bling)
);

$dispatcher{$action}->(<insert_common_args_here>) if exists($dispatche
+r{$action});

sub compute_interval {
   my $args = shift;
   return sub {
      # do something useful with args here..
   }
}

sub compute_interstice {
   my $args = shift;
   return sub {
      # and so on
   }
}
[download]