Syntax of Algernon

	query			=	(a-query string path)
	assertion		=	(a-assert string path)

	path	                = 	(form+ )  

	rule            	=	(form+ <- form+ ) | 
					(form+ -> form+ )  

	form            	=	predicate |  

					(:RULES  term rule+ ) | 
					(:SRULES term rule+ ) | 
					(:DEL-RULE term rule) | 
					(:DEL-SRULE term rule) | 
					(:DEL-RULES term slot) | 
					(:DEL-SRULES term slot) |  

					(:THE  variable form+ ) | 
					(:THE  (variable+ ) form+ ) | 
					(:FORC variable form+ ) | 
					(:FORC (variable+ ) form+ ) | 
					(:UNP form+ ) | 
					(:ALL-PATHS path path) |  

					(:ASSUME predicate) | 
					(:RETRIEVE predicate) | 
					(:ASK predicate) |  

					(:CREATE variable) | 
					(:CREATE variable atom+ ) | 
					(:SHOW term) |  

					(:DELETE predicate) | 
					(:CLEAR-SLOT term slot) |  

					(:DECL-SLOTS (slot number)+ ) | 
					(:SLOT atom (term+) descriptor*) |  

					(:LISP expression) | 
					(:BIND variable expression) |
                                        (:BIND-TO-VALUES variable term slot) |
                                        (:BRANCH-ON-VALUES variable expression) |
					(:APPLY function expression) | 
					(:NEQ term term)  

					(:TAXONOMY set-descriptor)  


	predicate		=	(slot term term+ ) | (not predicate) 

	term			=	variable | 
					f | 
					(slot term) | 
					(:SLOT slot) | 
					(:QUOTE expression) |
                                        (:LAMBDA variable path)

	descriptor		=	:cardinality number | 
					:partition term | 
					:backlink slot | 
					:inverse slot |  

	set-descriptor		=	(term set-descriptor* term*)  

	frame			=	Any lisp atom which is a name of a frame in the knowledge-base. 
	slot			=	Any lisp atom declared as a slot in the knowledge-base. 
	variable		=	Any lisp atom whose print name begins with a '?'.  

	number			=	Any number. 
	string			=	Any lisp string. 
	expression		=	Any lisp expression. 
	atom			=	Any lisp atom. 
	function		= 	Any lisp function (in a form sutable to be passed to apply).
