---------------------------------------------------------------
VALORES

- numeros enteros positivos (hasta ahora unicos soportados)
 se autoevaluan

- cadenas entrecomilladas

- booleanos
#t			(valor canonico de verdad)
#f == ()	(valor falso y lista vacia)

- simbolos
 evaluan al valor al que esten bindeados
 se pueden quotear
---------------------------------------------------------------
SPECIAL FORMS
	if cond1 expr1
	   ...
	   condN exprN
	   [else]
	 evalua la primera expr-i para la cual cond-i sea distinto
	 de #f. si todas las cond-i son #f y hay clausula else,
	 se devuelve el valor de evaluar esta
	 se parece mas a un cond de Lisp que a un if 

	do expr1 ... exprN
	  secuenciamiento ("progn", "begin")

	fun args . cuerpo
	  crea funciones anonimas ("lambda")

	set expresion valor
	  establece un valor. hasta ahora NO soporta variables
	  generalizadas (!= "setf" de common lisp)

	def variable valor
	  crea un binding en el entorno corriente

	quote expresion
	  cita una expresion (quote expr) == 'expr

---------------------------------------------------------------
FUNCIONES
usuales
	read
	eval

igualdad
	eq

aritmeticas
	+
	-
	*

mapping
	map	f . secuencias		guarda los resultados
	mapc f . secuencias		no guarda los resultados
	maplist f . secuencias	sobre los cdr, guarda los resultados
	mapl f . secuencias		sobre los cdr, no guarda los resultados

secuencias (listas, vectores y cadenas (vectores uniformes de char))
	cons
	car
	cdr
	list . elementos
	vec . elementos
	len seq					length
	cat . seq				concatena
	xrev seq				reverse (destructivo)
	elt indice seq			devuelve el enesimo elemento de una secuencia
	copy seq				hace una copia (shallow)
	index elemento seq		devuelve el indice en el que primero se
							encuentra el elemento en la secuencia
	member elemento lista [predicado]
							member del elemento sobre la lista con
							el predicado dado. por default, el predicado
							es eq
	assoc elemento lista [predicado]
							assoc del elemento. la lista debe tener
							la forma de una lista de asociacion. por
							default el predicado es eq

predicados
	consp

coerciones
	ord		(caracter -> entero)
	chr		(entero -> caracter)

entornos / simbolos
	env		devuelve el entorno actual (lista de hashes)
	gensym

errores
	err excepcion [errstr]
	  tira una excepcion (usualmente un simbolo) con una
	  cadena de error. si se omite, errstr es ""
	handle exc
	      funcion-handler
		  thunk
	  handle ejecuta el thunk (no recibe argumentos)
	  si se produce una excepcion, handle trata de atraparla
	  y pasarsela a la funcion handler.
	  si exc es #t, handle atrapa todas las excepciones
	  si exc evalua a un simbolo, handle atrapa las excepciones eq
	  a ese simbolo
	  si exc evalua a una lista, handle atrapa las excepciones member
	  de esa lista
	  funcion-handler debe recibir dos argumentos: la
	  excepcion cachada y una cadena de error

modulos
	load archivo		carga un archivo en el entorno actual
	import archivo		carga un archivo en un nuevo entorno
						y devuelve ese entorno

		BIND("get", fu_make_proc(fu_get_hash_eq, 2, 0, 0));

output
	out puerto cadena
	pr cadena [puerto]		imprime para humanos con un enter
	pr1 cadena [puerto]		imprime para humanos sin el enter
	wr cadena [puerto]		imprime representacion con un enter
	wr1 cadena [puerto]		imprime representacion sin el enter
	cr [puerto]				imprime el caracter 13, \r, carriage return
	lf [puerto]				imprime el caracter 10, \n, linefeed
	crlf [puerto]			imprime cr y lf

---------------------------------------------------------------
MACROS
	macro (nombre . argumentos) . cuerpo
		define un macro

	let ((var1 val1) ... (varN valN)) . cuerpo
		let usual
		se expande como ((fun (var1 ... varN) . cuerpo)
		                 val1 ... valN)

	each variable secuencia . cuerpo
		each a la Python
		ej:
		(each x '(1 2 3 4)
		  (pr x))
		se expande como (mapc
		                    (fun (x) (pr x))
							'(1 2 3 4))

	(try
  	  expresion
	  EXC-1		expr1
      ...
	  EXC-N		exprN
	  [ELSE])
		evalua la expresion
		si se produce alguna excepcion en el curso de dicha
		evaluacion, compara la excepcion con cada una de
		las EXC-l.
		si la EXC-I es un simbolo y la excepcion corriente
		es eq => evalua la exprI
		si la EXC-I es una lista y la excepcion corriente es
		member de esa lista => evalua la exprI

		si la excepcion no estaba prevista en ninguna EXC-I
		y hay clausula ELSE, se evalua la clausula ELSE.
		si no hay clausula ELSE, se vuelve a tirar la excepcion

		en las exprI, se produce captura de dos variables:
		exc y errstr. exc es la excepcion cachada y errstr
		es la cadena de error

---------------------------------------------------------------
VARIABLES

puertos
	*stdin*
	*stdout*
	*stderr*
