CONCEPT
	types

DESCRIPTION
	Variables can have one of the following types:

	int:	An integer. Normally full 32 bits signed.

	status:	A boolean, either 0 or 1 (same as int).

	string:	A string (not pointer to string).

	object: Pointer to an object.

	array: Pointer to a vector of values, which could also be an
	       alist.

	mapping: An 'associative array' where the indices can be of
	       any kind.

	closure: References to executable code, both to local
	       functions, efuns and to functions compiled at runtime
	       ("lambda closures").
	
	float: a floating point number. The interpreter must have the
		floats enabled at compile time.

	mixed: A variable allowed to take a value of any type.

	All uninitialized variables have the value 0. The type of a
	variable is really only a documentation, and has no effect at
	all on the program! (Note: this is no longer true if you use
	#pragma strict_types) A pointer to a destructed object will
	always have the value 0. 

	Global variables and functions in an object can have the type
	modifiers 'public', 'static', 'private', 'protected'.

	Private variables and functions can not be accessed by
	objects that inherit the object where the variable is defined.

	Static variables will not be saved by save_object(), or
	restored by restore_object(). Static functions cannot be
	called via call_other(), filter_*() or map_*() from other
	objects.

	Variables and functions that are declared as public cannot be
	made static or private by inheriting objects.

	It is also possible to specify the treatment of the inherited
	variables and functions in the inherit statement, e.g.:

	private variables static functions inherit "/foo/bar";

	The type modifier 'protected' is currently unused.

SEE ALSO
	alists(LPC), arrays(LPC), mappings(LPC), closures(LPC),
	typeof(E), get_type_info(E), inheritance(lpc), pragma(LPC)
