typeset [ {+|-}AHUaghlmprtux ] [ {+|-}EFLRZi [ n ] ]
        [ + ] [ name[=value] ... ]
typeset -T [ {+|-}Uglprux ] [ {+|-}LRZ [ n ] ]
        [ + | SCALAR[=value] array[=(value ...)] [ sep ] ]
typeset -f [ {+|-}TUkmtuz ] [ + ] [ name ... ]
       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.  All forms of the command handle scalar assignment.

       If any of the reserved words declare,  export,  float,  integer,
       local,  readonly  or  typeset is matched when the line is parsed
       (N.B. not when it is executed) the shell will try to parse argu-
       ments  as  assignments,  except  that  the  `+='  syntax and the
       GLOB_ASSIGN option are not supported.  This has two  major  dif-
       ferences  from  normal  command  line  argument  parsing:  array
       assignment is possible, and scalar values after = are not  split
       further  into  words even if expanded (regardless of the setting
       of the KSH_TYPESET option; this option is obsolete).  Here is an
       example:

              # Reserved word parsing
              typeset svar=$(echo one word) avar=(several words)

       The above creates a scalar parameter svar and an array parameter
       avar as if the assignments had been

              svar="one word"
              avar=(several words)

       On the other hand:

              # Normal builtin interface
              builtin typeset svar=$(echo two words)

       The builtin keyword causes the above to use the standard builtin
       interface  to  typeset  in which argument parsing is perfomed in
       the same way as for other  commands.   This  example  creates  a
       scalar  svar containing the value two and another scalar parame-
       ter words with no value.  An array  value  in  this  case  would
       either  cause  an  error or be treated as an obscure set of glob
       qualifiers.

       Arbitrary arguments are allowed if they take the form of assign-
       ments  after command line expansion; however, these only perform
       scalar assignment:

              var='svar=val'
              typeset $var

       The above sets the scalar  parameter  svar  to  the  value  val.
       Parentheses  around  the  value within var would not cause array
       assignment as they will be treated as ordinary  characters  when
       $var is substituted.  Any non-trivial expansion in the name part
       of the assignment causes the argument  to  be  treated  in  this
       fashion:

              typeset {var1,var2,var3}=name

       The  above  syntax is valid, and has the expected effect of set-
       ting the three parameters to the same  value,  but  the  command
       line  is  parsed as a set of three normal command line arguments
       to typeset after expansion.  Hence it is not possible to  assign
       to multiple arrays by this means.

       Note  that  each interface to any of the commands my be disabled
       separately.  For example,  `disable  -r  typeset'  disables  the
       reserved  word interface to typeset, exposing the builtin inter-
       face, while `disable typeset' disables the builtin.

       If the shell option TYPESET_SILENT is not set, for each  remain-
       ing  name  that  refers  to a parameter that is already 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 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.

       If  no  attribute  flags are given, and either no name arguments
       are present or the flag +m is used,  then  each  parameter  name
       printed  is preceded by a list of the attributes of that parame-
       ter (array, association, exported, float, integer, readonly,  or
       undefined  for  autoloaded parameters not yet loaded).  If +m is
       used with attribute flags, and all those  flags  are  introduced
       with  +, the matching parameter names are printed but their val-
       ues are not.

       The following control flags change the behavior of typeset:

       +      If `+' appears by itself in a separate word as  the  last
              option,  then the names of all parameters (functions with
              -f) are printed, but the  values  (function  bodies)  are
              not.   No  name  arguments may appear, and it is an error
              for any other options to follow `+'.  The effect  of  `+'
              is  as if all attribute flags which precede it were given
              with a `+' prefix.  For example, `typeset -U +' is equiv-
              alent  to  `typeset  +U'  and  displays  the names of all
              arrays having the uniqueness attribute, whereas  `typeset
              -f  -U  +'  displays  the names of all autoloadable func-
              tions.  If + is the only option,  then  type  information
              (array,  readonly, etc.) is also printed for each parame-
              ter, in the same manner as `typeset +m "*"'.

       -g     The -g (global) 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).

       -m     If the -m flag is given the name arguments are  taken  as
              patterns  (use quoting to prevent these from being inter-
              preted as file patterns).  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).

              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 and their attributes to
              be printed, even inside a  function.   Note  that  -m  is
              ignored  if  no  patterns are given, so `typeset -m' dis-
              plays attributes but `typeset -a +m' does not.

       -p     If the -p option is  given,  parameters  and  values  are
              printed  in  the form of a typeset command and an assign-
              ment (which will be printed  separately  for  arrays  and
              associative   arrays),  regardless  of  other  flags  and
              options.   Note  that  the  -H  flag  on  parameters   is
              respected; no value will be shown for these parameters.

              As the intention of this option is to produce output that
              can restore the current state, readonly  specials  (whose
              values  cannot  be changed) are not shown and assignments
              to arrays are shown  before  the  typeset  rendering  the
              array readonly.

       -T [ scalar[=value] array[=(value ...)] [ sep ] ]
              This  flag has a different meaning when used with -f; see
              below.  Otherwise the -T option requires  zero,  two,  or
              three  arguments  to  be present.  With no arguments, the
              list of parameters created  in  this  fashion  is  shown.
              With  two  or three arguments, the first two are the name
              of a scalar and of 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.
              Multibyte characters are not yet supported.

              Only  one  of  the  scalar  and  array  parameters may be
              assigned an initial value (the restrictions on assignment
              forms described above also apply).

              Both  the scalar and the array may be manipulated as nor-
              mal.  If one is unset, the other  will  automatically  be
              unset  too.   There  is  no  way of untying the variables
              without unsetting them, nor of 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.
              Setting the value using the scalar version causes a split
              on all separators (which cannot be quoted).  It is possi-
              ble to apply -T to two previously tied variables but with
              a different separator character, in which case the  vari-
              ables  remain  joined  as  before  but  the  separator is
              changed.

       Attribute flags that transform the final value (-L, -R, -Z,  -l,
       -u)  are  only  applied  to the expanded value at the point of a
       parameter expansion expression using `$'.  They are not  applied
       when  a  parameter  is retrieved internally by the shell for any
       purpose.

       The following attribute flags may be specified:

       -A     The names refer  to  associative  array  parameters;  see
              `Array Parameters' in zshparam(1).

       -L [ n ]
              Left  justify  and  remove  leading blanks from the value
              when the parameter is expanded.   If  n  is  nonzero,  it
              defines  the width of the field.  If n is zero, the width
              is determined by the width of  the  value  of  the  first
              assignment.   In  the  case  of  numeric  parameters, the
              length of the complete value assigned to the parameter is
              used  to determine the width, not the value that would be
              output.

              The width is the count of characters, which may be multi-
              byte  characters  if  the  MULTIBYTE option is in effect.
              Note that the screen width of the character is not  taken
              into  account;  if  this  is  required,  use padding with
              parameter expansion flags ${(ml...)...} as  described  in
              `Parameter Expansion Flags' in zshexpn(1).

              When the parameter is expanded, it is filled on the right
              with blanks or truncated if necessary to fit  the  field.
              Note  truncation  can  lead  to  unexpected  results with
              numeric parameters.  Leading zeros are removed if the  -Z
              flag is also set.

       -R [ n ]
              Similar  to  -L, except that right justification is used;
              when the parameter is expanded, the field is left  filled
              with  blanks  or truncated from the end.  May not be com-
              bined with the -Z flag.

       -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 [ n ]
              Specially handled if set along with the -L flag.   Other-
              wise,  similar  to -R, except that leading zeros are used
              for padding instead of  blanks  if  the  first  non-blank
              character  is  a digit.  Numeric parameters are specially
              handled:  they  are  always  eligible  for  padding  with
              zeroes,  and  the  zeroes  are inserted at an appropriate
              place in the output.

       -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, -T, -k, -u, -U and -z.  The flag -t turns on exe-
              cution tracing for this function; the flag  -T  does  the
              same,  but  turns off tracing on any function called from
              the present one, unless that function also has the -t  or
              -T  flag.   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  defini-
              tion  when the function is first referenced; see the sec-
              tion `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  function  is
              loaded.

              Note that the builtin functions provides the  same  basic
              capabilities  as  typeset  -f  but  gives access to a few
              extra options.

       -h     Hide: only useful for special  parameters  (those  marked
              `<S>' in the table in zshparam(1)), and for local parame-
              ters 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 [ n ]
              Use an internal integer representation.  If n is  nonzero
              it  defines  the  output arithmetic base, otherwise it is
              determined by the first assignment.  Bases from 2  to  36
              inclusive are allowed.

       -E [ n ]
              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 [ n ]
              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.

              If   the  POSIX_BUILTINS  option  is  set,  the  readonly
              attribute is more restrictive:  unset  variables  can  be
              marked  readonly and cannot then be set; furthermore, the
              readonly attribute cannot be removed from  any  variable.
              Note that in zsh (unlike other shells) it is still possi-
              ble to create a local variable of the same name  as  this
              is considered a different variable (though this variable,
              too, can be 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 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 [ {+|-}Hghlprtux ] [ {+|-}EFLRZ [ n ] ] [ name[=value] ... ]
       Equivalent  to  typeset  -E,  except  that options irrelevant to
       floating point numbers are not permitted.

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

local [ {+|-}AHUahlprtux ] [ {+|-}EFLRZi [ 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.
