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 func-
       tions -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)  un-
       less the called function also has the -W attribute.

       The  -c  option  causes oldfn to be copied to newfn.  The copy is
       efficiently 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  with-
       out  affecting  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 cor-
       responding 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  mathe-
       matical 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 ((...)) state-
       ments, 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 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 func-
       tion, so the return status ($?) of the function would be non-zero
       (indicating failure) whenever the arithmetic result of the  func-
       tion 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 argu-
       ment to the function is a single  string:  anything  between  the
       opening  and  matching closing parenthesis is passed to the func-
       tion as a single argument, even if it includes  commas  or  white
       space.   The  minimum and maximum argument specifiers must there-
       fore 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  func-
       tions  in the same form as a definition.  With the additional op-
       tion -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
       (regardless of whether its name coincides with mathfn).
