typeset [ {+|-}AEFHLRUZafghilprtuxm [n]] [ name[=value] ... ]
typeset -T [ {+|-}LRUZrux ] 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 remain-
       ing 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), regard-
       less of other flags and options.   Note  that  the  -h  flag  on
       parameters is respected; no value will be shown for these param-
       eters.

       If the -T option is  given,  two  or  three  arguments  must  be
       present (an exception is that zero arguments 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 significant;  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,  assign-
       ing  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.  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 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 (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  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.  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 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 [ {+|-}EFHghlprtux ] [ 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  func-
       tion 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 [ {+|-}Hghilprtux ] [ name[=value] ... ]
       Equivalent to typeset -i,  except  that  options  irrelevant  to
       integers are not permitted.

local [ {+|-}AEFHLRUZahilprtux [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.
