functions [ {+|-}UkmtTuWz ] [ -x num ] [ name ... ]
functions -c oldfn newfn
functions -M [-s] mathfn [ min [ max [ shellfn ] ] ]
functions -M [ -m pattern ... ]
functions +M [ -m ] mathfn ...
       Equivalent  to typeset -f, with the exception of the -c, -x, -M and
       -W options.  For functions -u and functions -U, see autoload, which
       provides additional options.  For functions -t  and  functions  -T,
       see typeset -f.

       The  -x  option  indicates that any functions output will have each
       leading tab for indentation, added by the shell to  show  syntactic
       structure,  expanded  to  the  given number num of spaces.  num can
       also be 0 to suppress all indentation.

       The -W option turns on the option  WARN_NESTED_VAR  for  the  named
       function  or functions only.  The option is turned off at the start
       of nested functions (apart from anonoymous  functions)  unless  the
       called function also has the -W attribute.

       The  -c option causes oldfn to be copied to newfn.  The copy is ef-
       ficiently handled internally by reference counting.  If  oldfn  was
       marked  for  autoload it is first loaded and if this fails the copy
       fails.  Either function may subsequently be redefined  without  af-
       fecting  the other.  A typical idiom is that oldfn is the name of a
       library shell function which  is  then  redefined  to  call  newfn,
       thereby installing a modified version of the function.

       The -M and +M flags

       Use  of  the  -M option may not be combined with any of the options
       handled by typeset -f.

       functions -M mathfn defines mathfn as the name  of  a  mathematical
       function  recognised  in all forms of arithmetical expressions; see
       the section `Arithmetic  Evaluation'  in  zshmisc(1).   By  default
       mathfn may take any number of comma-separated arguments.  If min is
       given,  it  must  have  exactly  min  args; if min and max are both
       given, it must have at least min and at most max args.  max may  be
       -1 to indicate that there is no upper limit.

       By  default  the function is implemented by a shell function of the
       same name; if shellfn is specified it gives the name of the  corre-
       sponding  shell  function  while  mathfn  remains  the name used in
       arithmetical expressions.  The name of the function in $0 is mathfn
       (not shellfn as would usually be the  case),  provided  the  option
       FUNCTION_ARGZERO  is  in  effect.  The positional parameters in the
       shell function correspond to  the  arguments  of  the  mathematical
       function call.

       The result of the last arithmetical expression evaluated inside the
       shell function gives the result of the mathematical function.  This
       is  not  limited  to arithmetic substitutions of the form $((...)),
       but also includes arithmetical expressions evaluated in  any  other
       way,  including by the let builtin, by ((...)) statements, and even
       by the return builtin and by  array  subscripts.   Therefore,  care
       must be taken not to use syntactical constructs that perform arith-
       metic  evaluation  after evaluating what is to be the result of the
       function.  For example:

              # WRONG
              zmath_cube() {
                (( $1 * $1 * $1 ))
                return 0
              }
              functions -M cube 1 1 zmath_cube
              print $(( cube(3) ))

       This will print `0' because of the return.

       Commenting the return out would lead to a  different  problem:  the
       ((...))  statement would become the last statement in the function,
       so the return status ($?) of the function would be non-zero  (indi-
       cating  failure)  whenever  the  arithmetic  result of the function
       would happen to be zero (numerically):

              # WRONG
              zmath_cube() {
                (( $1 * $1 * $1 ))
              }
              functions -M cube 1 1 zmath_cube
              print $(( cube(0) ))

       Instead, the true builtin can be used:

              # RIGHT
              zmath_cube() {
                (( $1 * $1 * $1 ))
                true
              }
              functions -M cube 1 1 zmath_cube
              print $(( cube(3) ))

       If the additional option -s is given to functions -M, the  argument
       to  the  function  is a single string: anything between the opening
       and matching closing parenthesis is passed to  the  function  as  a
       single  argument,  even  if it includes commas or white space.  The
       minimum and maximum argument specifiers  must  therefore  be  1  if
       given.   An  empty argument list is passed as a zero-length string.
       Thus, the following string function takes a  single  argument,  in-
       cluding the commas, and prints 11:

              stringfn() { (( $#1 )); true }
              functions -Ms stringfn
              print $(( stringfn(foo,bar,rod) ))

       functions  -M  with  no arguments lists all such user-defined func-
       tions in the same form as a definition.  With the additional option
       -m and a list of arguments, all functions whose mathfn matches  one
       of the pattern arguments are listed.

       function  +M  removes  the list of mathematical functions; with the
       additional option -m the arguments are treated as patterns and  all
       functions  whose mathfn matches the pattern are removed.  Note that
       the shell function implementing the behaviour is not  removed  (re-
       gardless of whether its name coincides with mathfn).
