typeset [ {+|-}AEFHLRUZafghiklprtuxmz [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 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 -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), regardless of other
       flags and options.  Note that the -h flag on param-
       eters  is  respected;  no  value  will be shown for
       these parameters.

       If the -T option is given, two or  three  arguments
       must  be  present  (an exception is that zero argu-
       ments 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  signifi-
       cant;  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 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
       (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 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, -k, -u,
              -U and -z.  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'. The -k and -z flags
              make  the function be loaded using ksh-style
              or zsh-style  autoloading  respectively.  If
              neither   is   given,  the  setting  of  the
              KSH AUTOLOAD option determines how the func-
              tion is loaded.

       -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
              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 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 [ {+|-}EFHghlprtux ] [ name[=value] ... ]
       Equivalent  to  typeset  -E,  except  that  options
       irrelevant  to  floating point numbers are not per-
       mitted.

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

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

       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.  If ksh-style autoloading is  enabled,
       the  function  created will contain the contents of
       the  file  plus  a  call  to  the  function  itself
       appended  to it, thus giving 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 [ {+|-}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 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.
