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
       zshparam(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  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 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  listing  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 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.
       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
              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  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
              zshparams(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
              special 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
              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  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
              arithmetic base, otherwise it is  determined
              by the first assignment.

       -E     Use  an  internal  double-precision floating
              point   representation.    On   output   the
              variable  will  be  converted  to scientific
              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   representation.    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 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
       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  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
       definition  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
       autoloading.

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.
