typeset [ {+|-}AEFLRUZafghilrtuxm [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 if  any
       attribute  flags listed below are given.  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 vari
       able 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 manipulated as nor
       mal.  If one is unset, the other will automatically
       be unset too.  There is no way of untying the vari
       ables 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 type
       set  -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  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.

       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 option  list  ends
       with  `+', values will not be printed.  If only the
       -m flag is given the arguments are  taken  as  pat
       terns  (which  should be quoted) and all parameters
       (or functions with the -f flag) with matching names
       are  printed.  If no attribute flags and no -m flag
       is present, the parameter names will be preceded by
       a  list  of  any  attributes  (array,  association,
       exported, integer, readonly).

       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; otherwise it  is  deter
              mined 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 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'.

       -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

              mapfile  and  parameter)  are  automatically
              given   the   -h  attribute  to  avoid  name
              clashes.

       -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.

       -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.

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

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 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.

       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  executed  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  autoload
       ing.

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

local [ {+|-}AEFLRUZahilrtux [n]] [ name[=value] ] ...
       Same as typeset, except that the options -g, and -f
       are not permitted.  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.
