typeset [ {+|-}AEFHUafghklprtuxmz ]  [  -LRZi  [  n  ]]  [
name[=value] ... ]
typeset -T [ {+|-}Urux ] [  -LRZ  [  n  ]]  SCALAR[=value]
array [ sep ]
       Set or display  attributes  and  values  for  shell
       parameters.

       A  parameter is created for each name that does not
       already refer to one.  When inside  a  function,  a
       new parameter is created for every name (even those
       that already exist), and is unset  again  when  the
       function completes.  See `Local Parameters' in zsh-
       param(1).  The same rules apply  to  special  shell
       parameters,  which  retain their special attributes
       when made local.

       For each name=value assignment, the parameter  name
       is set to value.  Note that arrays currently cannot
       be assigned in typeset  expressions,  only  scalars
       and integers.

       If  the shell option TYPESET SILENT is not set, for
       each remaining name that refers to a parameter that
       is  set,  the  name  and value of the parameter are
       printed in the form of an assignment.   Nothing  is
       printed  for  newly-created parameters, or when any
       attribute flags listed below are given  along  with
       the  name.  Using `+' instead of minus to introduce
       an attribute turns it off.

       If the -p option is given,  parameters  and  values
       are  printed in the form of a typeset comand and an
       assignment (which will be  printed  separately  for
       arrays and associative arrays), regardless of other
       flags and options.  Note that the -h flag on param-
       eters  is  respected;  no  value  will be shown for
       these parameters.

       If the -T option is given, two or  three  arguments
       must  be  present  (an exception is that zero argu-
       ments are allowed to show the  list  of  parameters
       created  in  this  fashion).  The first two are the
       name of a scalar and an array  parameter  (in  that
       order)  that will be tied together in the manner of
       $PATH and $path.  The optional third argument is  a
       single-character  separator  which  will be used to
       join the elements of the array to form the  scalar;
       if  absent,  a  colon is used, as with $PATH.  Only
       the first character of the  separator  is  signifi-
       cant;  any  remaining characters are ignored.  Only
       the scalar parameter may  be  assigned  an  initial
       value.  Both the scalar and the array may otherwise
       be manipulated as normal.  If  one  is  unset,  the
       other will automatically be unset too.  There is no
       way of  untying  the  variables  without  unsetting
       them,  or  converting  the type of one of them with
       another  typeset  command;  +T   does   not   work,
       assigning  an  array  to  SCALAR  is  an error, and
       assigning a scalar to array sets it to  be  a  sin-
       gle-element  array.   Note  that  both `typeset -xT
       ...'  and `export -T ...' work, but only the scalar
       will be marked for export.  Setting the value using
       the scalar version causes a split on all separators
       (which cannot be quoted).

       The -g (global) flag is treated specially: it means
       that any resulting parameter will not be restricted
       to  local scope.  Note that this does not necessar-
       ily mean that the parameter will be global, as  the
       flag  will apply to any existing parameter (even if
       unset) from an enclosing function.  This flag  does
       not  affect  the parameter after creation, hence it
       has no effect when listing existing parameters, nor
       does the flag +g have any effect except in combina-
       tion with -m (see below).

       If no name is present, the names and values of  all
       parameters are printed.  In this case the attribute
       flags restrict the display to only those parameters
       that  have  the specified attributes, and using `+'
       rather than `-' to introduce  the  flag  suppresses
       printing  of the values of parameters when there is
       no parameter name.  Also, if the last option is the
       word  `+',  then  names  are printed but values are
       not.

       If the -m flag is  given  the  name  arguments  are
       taken  as  patterns (which should be quoted).  With
       no attribute flags, all  parameters  (or  functions
       with  the  -f flag) with matching names are printed
       (the shell option TYPESET SILENT  is  not  used  in
       this case).  Note that -m is ignored if no patterns
       are given.  If the +g flag is combined with  -m,  a
       new  local  parameter is created for every matching
       parameter that is not already local.  Otherwise  -m
       applies  all  other  flags  or  assignments  to the
       existing parameters.  Except when  assignments  are
       made  with name=value, using +m forces the matching
       parameters to be printed, even inside a function.

       If no attribute flags are given and  either  no  -m
       flag  is  present  or  the  +m  form was used, each
       parameter name printed is preceded by a list of the
       attributes  of  that parameter (array, association,
       exported, integer, readonly).  If +m is  used  with
       attribute flags, and all those flags are introduced
       with +, the matching parameter  names  are  printed
       but their values are not.

       The following attribute flags may be specified:

       -A     The names refer to associative array parame-
              ters; see `Array Parameters' in zshparam(1).

       -L     Left  justify and remove leading blanks from
              value.  If n  is  nonzero,  it  defines  the
              width of the field.  If n is zero, the width
              is determined by the width of the  value  of
              the   first  assignment.   In  the  case  of
              numeric parameters, the length of  the  com-
              plete  value  assigned  to  the parameter is
              used to determine the width, not  the  value
              that would be output.  When the parameter is
              expanded, it is filled  on  the  right  with
              blanks  or truncated if necessary to fit the
              field.  Note truncation can  lead  to  unex-
              pected   results  with  numeric  parameters.
              Leading zeros are removed if the -Z flag  is
              also set.

       -R     Similar  to -L, except that right justifica-
              tion  is  used;  when   the   parameter   is
              expanded,  the  field  is  left  filled with
              blanks or truncated from the end.   May  not
              be combined with the -Z flag.

       -U     For arrays (but not for associative arrays),
              keep  only  the  first  occurrence  of  each
              duplicated  value.  This may also be set for
              colon-separated special parameters like PATH
              or  FIGNORE, etc.  This flag has a different
              meaning when used with -f; see below.

       -Z     Specially handled if set along with  the  -L
              flag.  Otherwise, similar to -R, except that
              leading zeros are used for  padding  instead
              of  blanks  if the first non-blank character
              is a digit.   Numeric  parameters  are  spe-
              cially handled: they are always eligible for
              padding with  zeroes,  and  the  zeroes  are
              inserted at an appropriate place in the out-
              put.

       -a     The names refer  to  array  parameters.   An
              array parameter may be created this way, but
              it may not be assigned  to  in  the  typeset
              statement.  When displaying, both normal and
              associative arrays are shown.

       -f     The names refer  to  functions  rather  than
              parameters.  No assignments can be made, and
              the only other valid flags are -t,  -k,  -u,
              -U  and  -z.  The flag -t turns on execution
              tracing for this function.  The  -u  and  -U
              flags  cause  the  function to be marked for
              autoloading; -U also causes alias  expansion
              to   be  suppressed  when  the  function  is
              loaded.   The  fpath   parameter   will   be
              searched  to  find  the  function definition
              when the function is first  referenced;  see
              the section `Functions'. The -k and -z flags
              make the function be loaded using  ksh-style
              or  zsh-style  autoloading  respectively. If
              neither  is  given,  the  setting   of   the
              KSH AUTOLOAD option determines how the func-
              tion is loaded.

       -h     Hide: only  useful  for  special  parameters
              (those  marked  `<S>'  in  the table in zsh-
              params(1)), and for  local  parameters  with
              the same name as a special parameter, though
              harmless for others.   A  special  parameter
              with this attribute will not retain its spe-
              cial effect when  made  local.   Thus  after
              `typeset  -h  PATH',  a  function containing
              `typeset PATH' will create an ordinary local
              parameter  without  the  usual  behaviour of
              PATH.  Alternatively,  the  local  parameter
              may  itself  be  given this attribute; hence
              inside a function `typeset -h PATH'  creates
              an  ordinary local parameter and the special
              PATH parameter is not altered  in  any  way.
              It is also possible to create a local param-
              eter using `typeset +h special',  where  the
              local  copy  of special will retain its spe-
              cial properties regardless of having the  -h
              attribute.  Global special parameters loaded
              from  shell  modules  (currently  those   in
              zsh/mapfile and zsh/parameter) are automati-
              cally given the -h attribute to  avoid  name
              clashes.

       -H     Hide  value: specifies that typeset will not
              display the  value  of  the  parameter  when
              listing  parameters;  the  display  for such
              parameters is always as if the `+' flag  had
              been  given.   Use  of  the  parameter is in
              other respects normal, and the  option  does
              not  apply  if the parameter is specified by
              name, or by  pattern  with  the  -m  option.
              This  is on by default for the parameters in
              the zsh/parameter and  zsh/mapfile  modules.
              Note,  however, that unlike the -h flag this
              is also useful for non-special parameters.

       -i     Use an internal integer representation.   If
              n  is  nonzero  it defines the output arith-
              metic base, otherwise it  is  determined  by
              the first assignment.

       -E     Use  an  internal  double-precision floating
              point representation.  On output  the  vari-
              able  will  be converted to scientific nota-
              tion.  If n is nonzero it defines the number
              of   significant  figures  to  display;  the
              default is ten.

       -F     Use an  internal  double-precision  floating
              point  representation.   On output the vari-
              able will be converted to fixed-point  deci-
              mal  notation.   If  n is nonzero it defines
              the number of digits to  display  after  the
              decimal point; the default is ten.

       -l     Convert  the  result  to lower case whenever
              the parameter is expanded.  The value is not
              converted when assigned.

       -r     The  given  names are marked readonly.  Note
              that if name is  a  special  parameter,  the
              readonly  attribute  can  be  turned on, but
              cannot then be turned off.

       -t     Tags the named  parameters.   Tags  have  no
              special meaning to the shell.  This flag has
              a different meaning when used with  -f;  see
              above.

       -u     Convert  the  result  to upper case whenever
              the parameter is expanded.  The value is not
              converted  when  assigned.   This flag has a
              different meaning when  used  with  -f;  see
              above.

       -x     Mark for automatic export to the environment
              of subsequently executed commands.   If  the
              option  GLOBAL EXPORT  is  set, this implies
              the option -g, unless +g is also  explicitly
              given;  in  other words the parameter is not
              made local to the enclosing function.   This
              is  for compatibility with previous versions
              of zsh.

declare
       Same as typeset.

functions [ {+|-}UXkmtuz ] [ name ... ]
       Equivalent to typeset -f.

autoload [ {+|-}UXktz ] [ -w ] [ name ... ]
       Equivalent to functions -u, with the  exception  of
       -X/+X and -w.

       The  flag  -X may be used only inside a shell func-
       tion, and may not be followed by a name.  It causes
       the  calling  function to be marked for autoloading
       and then immediately loaded and executed, with  the
       current  array  of  positional  parameters as argu-
       ments.  This replaces the  previous  definition  of
       the  function.  If no function definition is found,
       an error is printed and the function remains  unde-
       fined and marked for autoloading.

       The  flag  +X  attempts  to  load  each  name as an
       autoloaded function, but does not execute it.   The
       exit  status  is zero (success) if the function was
       not previously defined and a definition for it  was
       found.   This does not replace any existing defini-
       tion of the function.  The exit status  is  nonzero
       (failure)  if  the  function was already defined or
       when no definition was found.  In the  latter  case
       the  function  remains  undefined  and  marked  for
       autoloading.  If ksh-style autoloading is  enabled,
       the  function  created will contain the contents of
       the  file  plus  a  call  to  the  function  itself
       appended  to it, thus giving normal ksh autoloading
       behaviour on the first call to the function.

       With the -w flag, the names are taken as  names  of
       files  compiled  with the zcompile builtin, and all
       functions defined in them are marked for  autoload-
       ing.

readonly
       Same as typeset -r.
