typeset [ {+|-}AEFHLRUZafghilrtuxm [n]] [ name[=value] ... ]
typeset -T [ {+|-}LRUZrux ] SCALAR[=value] array
       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.

       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 -T option is given, exactly two (or zero) name  arguments
       must  be present.  They represent a scalar and an array (in that
       order) that will be tied together in the  manner  of  $PATH  and
       $path.   In other words, an array present in the latter variable
       appears as a scalar with the elements of  the  array  joined  by
       colons  in  the  former.   Only  the  scalar may have an initial
       value.  Both the scalar and the array may otherwise  be  manipu-
       lated  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 single-element array.  Note that both `typeset -xT ...' and
       `export  -T  ...'  work,  but only the scalar will be marked for
       export.

       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 necessarily 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 list-
       ing existing parameters, nor does the flag +g  have  any  effect
       except in combination 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 dis-
       play   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  parame-
       ters  (or  functions  with  the -f flag) with matching names are
       printed.  Note that -m is ignored if no patterns are given.   If
       the  +g  flag is combined with -m, a new local parameter is cre-
       ated 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,  associa-
       tion,   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 parameters; 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; otherwise
              it is determined by the width of the value of  the  first
              assignment.  When the parameter is expanded, it is filled
              on the right with blanks or truncated if necessary to fit
              the  field.   Leading zeros are removed if the -Z flag is
              also set.

       -R     Right justify and fill with  leading  blanks.   If  n  is
              nonzero  if  defines the width of the field; otherwise it
              is determined by the width of  the  value  of  the  first
              assignment.  When the parameter is expanded, the field is
              left filled with blanks or truncated from the end.

       -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     Right justify and fill with leading zeros  if  the  first
              non-blank  character  is  a digit and the -L flag has not
              been set.  If n is nonzero it defines the  width  of  the
              field;  otherwise  it  is  determined by the width of the
              value of the first assignment.

       -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, -u and -U.  The flag -t turns on execution trac-
              ing 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  refer-
              enced; see the section `Functions'.

       -h     Hide:  only  useful  for special parameters (those marked
              `<S>' in the table in zshparams(1)), and for local param-
              eters  with  the same name as a special parameter, though
              harmless for  others.   A  special  parameter  with  this
              attribute  will  not  retain its special effect when made
              local.  Thus after `typeset -h PATH', a function contain-
              ing  `typeset PATH' will create an ordinary local parame-
              ter 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  parameter using `typeset +h special', where the
              local copy of special will retain its special  properties
              regardless  of  having  the -h attribute.  Global special
              parameters loaded from shell modules (currently those  in
              zsh/mapfile  and  zsh/parameter)  are automatically 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 dis-
              play 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-spe-
              cial parameters.

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

       -E     Use an internal double-precision floating point represen-
              tation.  On output the variable will be converted to sci-
              entific  notation.  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 represen-
              tation.   On  output  the  variable  will be converted to
              fixed-point decimal 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.

       -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  subse-
              quently  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  com-
              patibility with previous versions of zsh.

declare
       Same as typeset.

float [ {+|-}EFHghlrtux ] [ name[=value] ... ]
       Equivalent to typeset -E,  except  that  options  irrelevant  to
       floating point numbers are not permitted.

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

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

       The flag -X may be used only inside a shell  function,  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 arguments.
       This replaces the previous definition of the  function.   If  no
       function  definition  is  found,  an  error  is  printed and the
       function remains undefined and marked for autoloading.

       The flag +X attempts to load each name as  an  autoloaded  func-
       tion,  but  does  not execute it.  The exit status is zero (suc-
       cess) if the function was not previously defined and  a  defini-
       tion for it was found.  This does not replace any existing defi-
       nition 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.

       The  flag  +X  may  be combined with either -k or -z to make the
       function be loaded using  ksh-style  or  zsh-style  autoloading,
       respectively.  If  neither  is given, the current setting of the
       KSH AUTOLOAD options determines how the function is loaded. With
       ksh-style autoloading, the contents of the file will not be exe-
       cuted immediately. Instead, the function  created  will  contain
       the  contents  of  the  file  plus a call to the function itself
       appended to it, thus given 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 autoloading.

integer [ {+|-}Hghilrtux ] [ name[=value] ... ]
       Equivalent to typeset -i,  except  that  options  irrelevant  to
       integers are not permitted.

local [ {+|-}AEFHLRUZahilrtux [n]] [ name[=value] ] ...
       Same as typeset, except that the options -g, and -f are not per-
       mitted.   In  this  case the -x option does not force the use of
       -g, i.e. exported variables will be local to functions.

readonly
       Same as typeset -r.
