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.   See  the
              description of the `autoload' builtin for details.

              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.
