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

       -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 [ {+|-}EFHghlrtux ] [ 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 [ {+|-}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 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.
