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.
