NAME
    Smart::Dispatch - first-class switch statements

SYNOPSIS
     use Smart::Dispatch;
     my $given = dispatcher {
       match qr{ ^[A-J] }ix, dispatch { "Volume 1" };
       match qr{ ^[K-Z] }ix, dispatch { "Volume 2" };
       otherwise failover { Carp::croak "unexpected surname" };
     };
     my $surname = "Inkster";
     say $surname, " is in ", $dispatch->($surname), " of the phone book.";

DESCRIPTION
    People have been using dispatch tables for years. They work along the
    lines of:

     my $thing = get_foo_or_bar();
 
     my %dispatch = (
       foo   => sub { ... },
       bar   => sub { ... },
       );
     $dispatch{$thing}->();

    Dispatch tables are often more elegant than long groups of
    `if`/`elsif`/`else` statements, but they do have drawbacks. Consider how
    you'd change the example above to deal with $thing being not just "foo" or
    "bar", but adding all integers to the allowed values.

    Perl 5.10 introduced smart match and the `given` block. This allows stuff
    like:

     my $thing = get_foo_or_bar();
 
     given ($thing)
     {
       when ("foo") { ... }
       when ("bar") { ... }
       when (looks_like_number($_)) { ... }
     }

    The conditions in `when` clauses can be arbirarily complex tests, and
    default to comparisons using the smart match operator. This is far more
    flexible.

    `given` blocks do have some drawbacks over dispatch tables though. A
    dispatch table is a first class object - you can put a reference to it in
    a variable, and pass that reference as an argument to functions. You can
    check to see whether a dispatch table contains particular entries:

     if ($dispatch{"foo"})  # dispatch table can deal with $thing="foo"

    If passed a reference to an existing dispatch table, you can easily add
    entries to it, or remove entries from it.

    Smart::Dispatch is an attempt to combine some of the more useful features
    of `given` with dispatch tables.

  Building a Dispatch Table
    All the keywords used a build a dispatch table are lexical subs, which
    means that you can import them into a particular code block and they will
    not be available outside that block.

   `dispatcher { CODE }`
    A dispatch table is built using the `dispatcher` function which takes a
    single block argument. This block will typically consist of a number of
    `match` statements, though you can theoretically put anything you want
    inside it. (The code is run just once, when the dispatch table is being
    built, and is called in void context.)

     my $dispatch_table = dispatcher { ... };

    The return value is an Smart::Dispatch::Table object.

   `match $test, %args`
    The `match` function adds a single entry to the current dispatch table.
    The entry is a Smart::Dispatch::Match object.

    The $test argument is the trigger for dispatching to that particular entry
    in the table. It's like the contents of `when(...)` in a `given` block. It
    is used as the right hand argument to a smart match operation (see
    perlop), so it can be a string/numeric constant, `undef`, a `qr/.../`
    quoted regular expression, or a coderef, or an reference to an array
    containing any of the above. (There are other possibilities too, though
    they are somewhat obscure.)

    The hash of other arguments is passed to the constructor of
    Smart::Dispatch::Match.

   `dispatch { CODE }`
    This introduces the code to run when a match has been successful. It is
    used as follows:

     my $dispatch_table = dispatcher {
       match "foo", dispatch { "Monkey" };
       match "bar", dispatch { my $x = get_simian(); return $x };
     };

    Actually the above is just syntactic sugar for

     my $dispatch_table = dispatcher {
       match "foo", 'dispatch' => sub { "Monkey" };
       match "bar", 'dispatch' => sub { my $x = get_simian(); return $x };
     };

    So the only thing `dispatch` is doing is depositing a coderef into the
    %args hash of `match`.

   `value => $value`
    In the case of the "Monkey" bit above, it's actually a little wasteful to
    define a coderef (and run it when we do the dispatching later on) just to
    return a constant string, so in this case we can use the 'value' argument
    for `match`, to provide a slight optimization:

     my $dispatch_table = dispatcher {
       match "foo", value => "Monkey";
       match "bar", dispatch { my $x = get_simian(); return $x };
     };

    Note that `value` is not a function. It's just a named argument for
    `match`. Nothing much magic is going on.

   `match_using { CODE } %args`
    `match_using` is exactly like `match` but declared with a coderef
    prototype (see perlsub). That is, it just gives you syntactic sugar for
    the case where $test is a coderef. The following are equivalent:

    `match_using { $_ < 5 } dispatch { say "$_ is low" };`
    `match sub { $_ < 5 }, 'dispatch' => sub { say "$_ is low" };`

   `otherwise %args`
    `otherwise` is equivalent to `default` in `given` blocks, or `else` in
    `if` blocks. It matches all other cases, and must thus be the last match
    declared.

    Again this is really just syntactic sugar. The following are equivalent:

    `otherwise dispatch { undef };`
    `match sub { 1 }, 'is_unconditional' => 1, 'dispatch' => sub { undef };`

    Note that `otherwise` explicitly marks the match as an "unconditional"
    match. This allows Smart::Dispatch to complain if `otherwise` is not the
    last match in a dispatch table. And it helps when you try to combine
    multiple dispatch tables to know which is the "otherwise" match.

   `failover { CODE }`
    This is roughly the same as `dispatch`, but is intended for marking
    dispatches that can be regarded as failures:

     my $roman = dispatcher {
       match qr{\D}, failover { croak "non-numeric" };
       match [1..3], dispatch { "I" x $_ };
       match 4, value => 'IV';
       match [5..8], dispatch { 'V'.('I' x ($_-5)) };
       match 9, value => 'IX';
       match 10, value => 'X';
       otherwise failover { croak "out of range" };
     };

    In terms of actually dispatching from the dispatch table, failovers work
    exactly the same as any other dispatches. However, because the dispatch
    table knows which matches are successes and which are failures, this
    information can be queried.

    It should be no surprise by now that the `failover` function is just
    syntactic sugar, and the same effect can be achieved without it. The
    following are equivalent:

    `match $test, failover {...};`
    `match $test, 'is_failover' => 1, 'dispatch' => sub {...};`

  Using a Dispatch Table
    OK, so now you know how to build a dispatch table, but once we've got one,
    how can we use it?

    Dispatch tables, although they are not coderefs, overload `&{}`, which
    means they can be called like coderefs.

     my $biological_sex = dispatcher {
       match 'XX',         dispatch { 'Female' };
       match ['XY', 'YX'], dispatch { 'Male' };
       otherwise           failover { '????' };
     };
 
     my $sex_chromosomes = 'XY';
     say "I am a ", $biological_sex->($sex_chromosomes);

    The above will say "I am a Male".

    Note that the dispatch and failover subs here are pretty boring (we could
    have just used `<value`>), but any arbitrary Perl function is allowed.
    Perl functions of course accept argument lists. Any argument list passed
    into the dispatch table will be passed on to the dispatched function.

     my $biological_sex = dispatcher {
       match 'XX',
         dispatch { $_[1] eq 'fr' ? 'Femelle' : 'Female' };
       match ['XY', 'YX'],
         dispatch { $_[1] eq 'fr' ? 'Male' : 'Male' };
       otherwise
         failover { '????' };
     };
 
     my $sex_chromosomes = 'XX';
     say "I am a ", $biological_sex->($sex_chromosomes, 'en');
     say "Je suis ", $biological_sex->($sex_chromosomes, 'fr');

    Note that within `match_using`, `dispatch` and `failover` blocks, the
    value being matched is available in the variable $_. The following match
    demonstrates this:

     match_using { $_ < 5 } dispatch { say "$_ is low" }

    It is possible to check whether a dispatch table is able to handle a
    particular value.

     my $sex_chromosomes = 'AA';
     if ($biological_sex ~~ $sex_chromosomes)
     {
       say "Dispatch table cannot handle chromosomes $sex_chromosomes";
     }
     else
     {
       say $biological_sex->($sex_chromosomes);
     }

    This is where `failover` comes in. Failover matches are not considered
    when determining whether a dispatch table is capable of handling a value.

  Manipulating Dispatch Tables
    If you have an existing dispatch table, it's possible to add more entries
    to it. For this purpose, Smart::Dispatch overloads the `.=` and `+=`
    operators.

     my $more_sexes = dispatcher {
       match 'XYY',  dispatch { 'Supermale' };
       match 'XXX',  dispatch { 'Superfemale' };
     };
     $biological_sex .= $more_sexes;

    The difference between the two operators is the priority is which matches
    are tested.

     my $match1 = dispatcher {
       match 1, dispatch { 'One' };
     };

    We can add some more matches like this:

     $match1 .= dispatcher {
       match qr{^1}, dispatch { 'Leading one' };
     };

    When dispatching value "1", the result will still be "One", because the
    added matches have lower priority than the original ones.

    But if they are combined as:

     $match += dispatcher {
       match qr{^1}, dispatch { 'Leading one' };
     };

    Then when dispatching value "1", the result will be "Leading one" because
    the newer matches are given higher priority.

    It is also possible to use `.` and `+` in their non-assignment forms:

     my $enormous_match = $big_match . $large_match . $mighty_match;

    (Some future version may introduce the ability to do subtraction, but
    there are difficulties with this concept. For now, if you want to do
    subtraction, look at the internals of Smart::Dispatch::Table.)

    If one or both dispatch tables contain an unconditional match
    (`otherwise`), then these will be combined intelligently. The result will
    only have one unconditional match (the higher priority one).

  Import
    By default Smart::Dispatch exports the following functions:

    *   `dispatch`

    *   `dispatcher`

    *   `failover`

    *   `match`

    *   `match_using`

    *   `otherwise`

    It is possible to only import a subset of those:

     use Smart::Dispatch qw/dispatcher match otherwise/;

    As noted in the "Building a Dispatch Table" section, a minimal set of
    functions is just `dispatcher` and `match`. All the others are just
    syntactic sugar. If you just want those two, then you can do:

     use Smart::Dispatch qw/:tiny/;

    Smart::Dispatch uses Sub::Exporter which provides a dizzying array of cool
    options, such as:

     use Smart::Dispatch -all => { -prefix => 'sd_' };

    which imports all the symbols but prefixed with "sd_".

     use Smart::Dispatch
       qw/dispatcher dispatch match/,
       otherwise => { -as => 'last_resort' };

    which renames "otherwise" to "last_resort".

    If you've written subclasses of Smart::Dispatch::Table and
    Smart::Dispatch::Match and you want Smart::Dispatch to use your
    subclasses, then you can do this:

     use Smart::Dispatch
       qw/dispatcher dispatch match/,
       otherwise => { -as => 'last_resort' },
       class => {
         table => 'My::Dispatch::Table',
         match => 'My::Dispatch::Match',
         };

    Whatsmore, the `class` option can be set on a keyword-by-keyword basis for
    `match`, `match_using` and `otherwise`.

     use Smart::Dispatch
       qw/dispatcher dispatch match/,
       otherwise => {
         -as   => 'last_resort',
         class => 'My::Other::Match',
         },
       class => {
         table => 'My::Dispatch::Table',
         match => 'My::Dispatch::Match',
         };

  Constants
    *   `DEFAULT_MATCH_CLASS`

    *   `DEFAULT_TABLE_CLASS`

  Dispatch Table Internals
    See Smart::Dispatch::Table and Smart::Dispatch::Match.

    Note that this is an early release, so the internals are still likely to
    change somewhat between versions. The function-based API should be fairly
    steady though.

BUGS
    Please report any bugs to
    <http://rt.cpan.org/Dist/Display.html?Queue=Smart-Dispatch>.

SEE ALSO
    "Switch statements" in perlsyn; Acme::Given::Hash.

    <http://www.perlmonks.org/?node_id=954831>.

AUTHOR
    Toby Inkster <tobyink@cpan.org>.

COPYRIGHT AND LICENCE
    This software is copyright (c) 2012 by Toby Inkster.

    This is free software; you can redistribute it and/or modify it under the
    same terms as the Perl 5 programming language system itself.

DISCLAIMER OF WARRANTIES
    THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
    WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
    MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.

