The following symbols are exported from the csp package:

spawn (&rest forms)

	Macro. Creates a new thread to run forms (an implicit progn),
	concurrently with the current thread. Values of the dynamic variables named in
	*dynamic-variables* will be inherited by the new thread (see
	inherit and add-inherit). Returns a handle for the new thread, 

chan (&optional n)

	Function. Creates a new communication channel.
	The number of items buffered by the channel is given by n
	(default 0, meaning that communicating threads rendezvous
	at the moment of communication). Returns the new channel.

? (chan)
	Function. Receives a value from chan. If the channel is empty,
	this will block until a thread tries to send a value on it.
	If several threads are blocked sending, one will be chosen non-deterministically.
	Returns the value received.

! (chan value)
	Function. Send value down chan, blocking if the channel is full and
	there is no thread waiting to receive on it. Returns value.

alt (&body body)
	Macro. Wait for any of a set of communication events to occur,
	and execute associated code.
	The syntax is:

		alt ((op) form*)*
		op ::= (? chan [lambda-list]) | (! chan value) | :*

	where
		chan -- a form, evaluated once to produce a channel;
		lambda-list -- a destructuring lambda list;
		value -- a form, evaluated once to produce a value.
		forms -- an implicit progn.
	
	Each clause in the alt (except the :* form) represents a channel
	operation; ! names a send operation; ? names a receive operation.
	Alt selects (non deterministically) a clause that is currently
	executable. If none is found and there is a :* clause, then its
	forms will be evaluated, otherwise the alt blocks until a clause
	becomes ready, whereupon its associated forms are evaluated.
	For a receive (?) clause, the value received on the channel is
	bound to the values in lambda-list as for destructuring-bind.
	If no lambda-list is given, the value will be ignored.
	Alt returns the value of the last form executed.

kill (thread)
	Function. Destroy thread (a handle as returned from spawn).
	This is done by arranging for thread to raise a
	terminate condition (which is handled and ignored at the
	lowest level of each thread).

inherit (vars &rest forms)
	Macro. Vars is evaluated once to produce a list of
	names of dynamic variables; it then evaluates forms
	(an implicit progn), having arranged that each variable
	in vars will be inherited by any spawned threads (and
	any further descendents).

add-inherit (vars)
	Function. Similar to inherit, except it adds the dynamic variables
	referred to in vars to the variables that the current thread will inherit.

terminate
	The condition type used by kill.

channel
	The channel type.

*proc*
	A dynamic variable giving the thread handle for the current thread.

*dynamic-variables*
	A dynamic variable naming all dynamic variables to be
	inherited by threads spawned by the current thread.
	This should always include *dynamic-variables* itself.
