
The ability for users to define types has been added to ksh93t.
Here is a quick summary of how types are defined and used in ksh93t.
This is still a work in progress so some changes and additions
are likely.

A type can be defined either by a shared library or by using the new
typeset -T option to the shell.  The method for defining types via
a shared library is not described here.  However, the source file
bltins/enum.c is an example of a builtin that creates enumeration types.

By convention, typenames begin with a capital letter and end in _t.
To define a type, use
	typeset -T Type_t=(
		definition
	)
where definition contains assignment commands, declaration commands,
and function definitions.  A declaration command (for example typeset,
readonly, and export), is a built-in that differs from other builtins in
that tilde expansion is performed on arguments after an =, assignments
do not have to precede the command name, and field splitting and pathname
expansion is not performed on the arguments.
For example,
	typeset -T Pt_t=(
		float -h 'length in inches' x=1
		float -h 'width in inches' y=0
		integer -S count=0
		len()
		{
			print -r $((sqrt(_.x*_.x + _.y*_.y)))
		}
		set()
		{
			(( _.count++))
		}
	)

defines a type Pt_t that has three variables x, y, and count defined as well
as the discipline functions len and set.  The variable x has an initial value
of 1 and the variable y has an initial value of 0.  The new -h option argument,
is used for documentations purposes as described later and is ignored outside
of a type definition.


The variable count has the new -S attribute which means that it is shared
between all instances of the type.  The -S option to typeset is ignored
outside of a type definition.  Note the variable named _ that is used inside
the function definition for len and set.  It will be a reference to the
instance of Pt_t that invoked the function.  The functions len and set
could also have been defined with function len and function set, but
since there are no local variables, the len() and set() form are more
efficient since they don't need to set up a context for local variables
and for saving and restoring traps.

If the discipline function named create is defined it will be
invoked when creating each instance for that type. A function named
create cannot be defined by any instance.

When a type is defined, a declaration built-in command by this name
is added to ksh.  As with other shell builtins, you can get the man page
for this newly added command by invoking Pt_t --man.  The information from
the -h options will be embedded in this man page.  Any functions that
use getopts to process arguments will be cross-referenced on the generated
man page.

Since Pt_t is now a declaration command it can be used in the definition
of other types, for example
	typeset -T Rect_t=( Pt_t ur ll)

Because a type definition is a command, it can be loaded on first reference
by putting the definition into a file that is found on FPATH.
Thus, if this definition is in a file named Pt_t on FPATH, then
a program can create instances of Pt_t without first including
the definition.

A type definition is readonly and cannot be unset.  Unsetting non-shared
elements of a type restores them to their default value.  Unsetting a
shared element has no effect.

The Pt_t command is used to create an instance of Pt_t.
	Pt_t p1
creates an instance named p1 with the initial value for p1.x set to 1
and the initial value of p1.y set to 0.
	Pt_t p2=(x=3 y=4)
creates an instance with the specified initial values.  The len function
gives the distance of the point to the origin.  Thus, p1.len will output
1 and p2.len will output 5.

ksh93t also introduces a more efficient command substitution mechanism.
Instead of $(command), the new command substitution ${ command;}
can be used.  Unlike (and ) which are always special, the { and } are
reserved words and require the space after { and a newline or ; before }.
Unlike $(), the ${ ;} command substitution executes the command in
the current shell context saving the need to save and restore
changes, therefore also allowing side effects.

When trying to expand an element of a type, if the element does not exist,
ksh will look for a discipline function with that name and treat this as if
it were the ${ ;} command substitution.  Thus, ${p1.len} is equivalent to
${ p1.len;} and within an arithmetic expression, p1.len will be expanded
via the new command substitution method.

The type of any variable can be obtained from the new prefix
operator @.  Thus, ${@p1} will output Pt_t.

By default, each instance inherits all the discipline functions defined
by the type definition other than create.  However, each instance can define
a function by the same name that will override this definition.
However, only discipline functions with the same name as those defined
by the type or the standard get, set, append, and unset disciplines
can be defined by each instance.

Each instance of the type Pt_t behaves like a compound variable except
that only the variables defined by the type can be referenced or set.
Thus, p2.x=9 is valid, but p2.z=9 is not.  Unless a set discipline function
does otherwise, the value of $p1 will be expanded to the form of a compound
variable that can be used for reinput into ksh.

If the variables var1 and var2 are of the same type, then the assignment
	var2=var1
will create a copy of the variable var1 into var2.  This is equivalent to
	eval var2="$var1"
but is faster since the variable does not need to get expanded or reparsed.

The type Pt_t can be referenced as if it were a variable using the name
.sh.type.Pt_t.  To change the default point location for subsequent
instances of Pt_t, you can do
	.sh.type.Pt_t=(x=5 y=12)
so that
	Pt_t p3
	p3.len
would be 13.

Types can be defined for simple variables as well as for compound
objects such as Pt_t.  In this case, the variable named . inside
the definition refers to the real value for the variable.  For example,
the type definition
	typeset -T Time_t=(
		integer .=0
		_='%H:%M:%S'
		get()
		{
			.sh.value=$(printf "%(${_._})T" "#$((_))" )
		}
		set()
		{
			.sh.value=$(printf "%(%#)T" "${.sh.value}")

		}
	)

The sub-variable name _ is reserved for data used by discipline functions
and will not be included with data written with the %B option to printf.
In this case it is used to specify a date format.

In this case
	Time_t t1 t2=now
will define t1 as the time at the beginning of the epoch and t2
as the current time.  Unlike the previous case, $t2 will output
the current time in the date format specified by the value t2._.
However, the value of ${t2.} will expand the instance to a form
that can be used as input to the shell.

Finally, types can be derived from an existing type.  If the first
element in a type definition is named _, then the new type
consists of all the elements and discipline functions from the
type of _ extended by elements and discipline functions defined
by new type definition.  For example,

	typeset -T Pq_t=(
		Pt_t _
		float z=0.
		len()
		{
			print -r $((sqrt(_.x*_.x + _.y*_.y + _.z*_.z)))
		}
	)

defines a new type Pq_t which is based on Pq_t and contains an additional
field z and a different len discipline function.  It is also possible
to create a new type Pt_t based on the original Pt_t.  In this case
the original Pt_t is no longer accessible.
