typeset [ {+|-}AEFHUafghklprtuxmz ] [ -LRZi [ n ]] [ name[=value] ... ]
typeset -T [ {+|-}Urux ] [ -LRZ [ n ]] 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.   Unless  the  option
       KSH_TYPESET  is  set, normal expansion rules apply to assignment
       arguments, so value may be split into  separate  words;  if  the
       option  is  set, assignments which can be recognised when expan-
       sion is performed are treated as single words.  For example  the
       command  typeset  vbl=$(echo  one  two) is treated as having one
       argument if KSH_TYPESET is set, but otherwise is treated as hav-
       ing the two arguments vbl=one and two.

       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 command 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).  It is possible to use the same two tied variables with
       a  different  separator  character  in  which case the variables
       remain joined as before but the separator is changed.  This flag
       has a different meaning when used with -f; see below.

       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.

       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     Left justify and remove leading blanks from value.  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 parame-
              ters, 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     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     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.

       -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     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     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 ] [ -LRZ [ n ]] [ name[=value] ... ]
       Equivalent  to  typeset  -E,  except  that options irrelevant to
       floating point numbers are not permitted.

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

local [ {+|-}AEFHUahlprtux ] [ -LRZi [ 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.
