NAME

       Kavorka::Manual::Functions - fun keyword

DESCRIPTION

       Kavorka provides the "fun" keyword for the purpose of defining functions (as against methods, etc).

       The anatomy of a function:

       1.  The keyword introducing the function.

       2.  The function name (optional).

       3.  The signature (optional).

       4.  Traits (optional).

       5.  The prototype (optional).

       6.  The attribute list (optional).

       7.  The function body.

       Example:

          #  (1) (2)    (3)          (4)     (5)   (6)     (7)
             fun foobar ($foo, $bar) is cool :($$) :cached { return $foo + $bar }

          #          (1) (6)
             my $f = fun { return $_[0] + $_[1] };

   The Keyword
       This requires very little explanation. If you're no fun, and don't like the name "fun", you can export it
       with a different name:

          use Kavorka fun => { -as => 'function' };

   The Function Name
       If  present,  it specifies the name of the function being defined. If no name is present, the declaration
       is an expression that evaluates to a reference to the function in question.

       Functions are automatically forward-declared; a la

          sub foobar ($$);

       but are installed into the symbol table at run-time. So this works:

          if ($ENV{DEBUG}) {
             fun foobar { ... }
          }
          else {
             fun foobar { ... }
          }

       It is possible to install the function at compile time using the "begin" trait:

          fun foobar but begin { ... }

       It is possible to define lexical functions using a lexical variable for a function name:

          fun my $add ($x, $y) {
             $x + $y;
          }

          my $sum = $add->(20, 22);

   The Signature
       See Kavorka::Manual::Signatures.

   Traits
       See Kavorka::Manual::ExtendingKavorka.

   The Prototype
       See Kavorka::Manual::PrototypeAndAttributes.

   The Attributes
       Attributes may alternatively be provided before the signature.

       See Kavorka::Manual::PrototypeAndAttributes.

   The Function Body
       This is more or less what you'd expect from the function body you'd write with sub, however  the  lexical
       variables for parameters are pre-declared and pre-populated.

   "f", "func", and "function"
       These are all aliases for "fun", though not exported by default.

          use v5.14;
          use Kavorka qw( function f );

          function make_plusser (Num $x = 1)
          {
             return f(Num $y) { $x + $y };
          }

          my $plusser = make_plusser();
          say $plusser->(41);   # says 42

BUGS

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

SEE ALSO

       Kavorka::Manual,           Kavorka::Manual::Signatures,          Kavorka::Manual::PrototypeAndAttributes,
       Kavorka::Manual::MultiSubs.

AUTHOR

       Toby Inkster <tobyink@cpan.org>.

COPYRIGHT AND LICENCE

       This software is copyright (c) 2013-2014 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.

perl v5.24.1                                       2016-12-15                    Kavorka::Manual::Functions(3pm)