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 effi-
       ciently 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 arith-
       metical  expressions.  The name of the function in $0 is mathfn (not
       shellfn as would usually be the case),  provided  the  option  FUNC-
       TION_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 arithmetic
       evaluation after evaluating what is to be the result  of  the  func-
       tion.  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, including 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 functions
       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 ad-
       ditional  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).
