DKW> Ok, how about a rough draft that can be
DKW> criticized/expanded/revised? The following is not a definitive
DKW> answer: someone with more knowledge, experience, and writing
DKW> ability could doubtless do better, but at least it's a start. If
DKW> nothing else, maybe it will encourage someone else to write
DKW> something better from scratch.
good start.
DKW> How do I call a subroutine or get the value of a variable when I
DKW> have the name of the subroutine or variable?
DKW> Use a dispatch table. A dispatch table is implemented with a
DKW> hash, which allows you to associate a string value with a
DKW> reference. (see L<perlref>) Since references can refer to
DKW> (nearly) anything, this permits great flexibility.
a dispatch table is the special name for a hash with code refs. this
should be separated from the lookup var by name stuff.
DKW> For example, here is a dispatch table using subroutine references:
DKW> my %dispatch = (
DKW> update => \&update,
DKW> add => \&add,
DKW> error => sub { die "Error: @_" }
DKW> default => \&do_something,
DKW> );
DKW> If we have a desired name in the scalar C<$input>, the associated
DKW> subroutine can be called using C<$dispatch{$input}->()>. The
DKW> subroutines do not have to be written by you; you can import
DKW> functions from a module and use them in your dispatch table.
import is not needed either. fully qualified sub names are ok.
better to say that the values of the dispatch table are CODE
references. they can be refs to named subs in (or imported into) this
module, refs to fully qualified sub names, and also anonymous CODE refs.
DKW> The code should always handle the case where the input value is
DKW> not a key of C<%dispatch>, so we might implement the call like
DKW> this:
DKW> if ( exists $dispatch{$input} ) {
DKW> $dispatch{$input}->(@arguments);
DKW> }
DKW> else {
DKW> $dispatch{'default'}->();
missing @arguments here
DKW> # or perhaps an error message... TMTOWTDI
DKW> }
or merging the default into the main case:
($dispatch{$input} || $dispatch{'default'})->(@arguments);
($dispatch{$input} || $default_sub)->(@arguments);
point to make: put the creation of the dispatch table outside of any sub
that uses it so it is created at compile time and not recreated in each
call to the sub that does the dispatching. of course unless there is a
reason to create the table dynamically (and i haven't seen many of those).
DKW> or perhaps like this:
DKW> my $routine = $dispatch{$input} || die "Cannot find code for $input";
DKW> $routine->(@arguments);
or:
DKW> The hash entries can be references to any data structure. Here is an
DKW> example using arrays:
DKW> my %dispatch = (
DKW> default => \@default,
DKW> 1 => \@data1,
DKW> 2 => \@data2,
DKW> other => \@other
DKW> );
DKW> Now if we want to print the values in @data1 with commas between the
DKW> elements, we could say
DKW> print join ',', @{$dispatch{1}};
dispatch is only for sub calling hashes. you dispatch through a sub. the
name and concept predates perl (i did this in assembly decades
ago). this is just basic data structure stuff. the reader should be
refered to perlreftut, perlref, perldsc and perllol
DKW> [Maybe a note here about common practical uses of dispatch tables? Or
DKW> should that be at the beginning?]
good idea.
uri
