anchor.diff:          (if (funcall f a) (append xs (list a)) xs)))
   
   (defun tomar-cuando (f xs)
  -    (let ((x (car xs))
  -          (rest (cdr xs)))
  -        (if xs (let ((resultado (reducir (anadir-verdad f) rest (list x)))
  -                    (anadir-primero (funcall f x)))
  -                    (if anadir-primero resultado (cdr resultado)))
  -            xs)))
  +    (reducir (anadir-verdad f) xs '()))
   
  -(defun igual-5 (a) (format t "~D~%" a) (= a 5))
  +(defun igual-5 (a) (= 5 a))
   
  -(defun tomar-tantos-cuando (f n xs)
  -    (defun tomar-tantos-cuando-p (f n xs ys)
  -        (let ((x (car xs))
  -              (rest (cdr xs)))
  -            (if xs
  -                (cond
  -                    ((> n 0) 
  -                        (cond
  -                            ((funcall f x) (tomar-tantos-cuando-p f (- n 1) rest (append ys (list x))))
  -                            (t (tomar-tantos-cuando-p f (- n 1) rest ys))))
  -                    (t ys))
  -                ys)))
  -    (tomar-tantos-cuando-p f n xs '()))
  +(defun tomar-tantos-cuando (n f xs)
  +    (tomar n (tomar-cuando f xs)))
  +
  +(defun generar-divisor? (n)
  +    (lambda (a)
  +        (if (= 0 (mod a n)) t nil)))
  +
  +(defun rango (max &key (min 0) (paso 1))
  +  (loop for n from min below max by paso
  +     collect n))
  +
  +(defun aplicar-a (a)
  +  (lambda (f)
  +    (funcall f a)))
  +
  +(defun y-funciones (&rest fs)
  +  (lambda (x)
  +    (reducir #'y-logico (mapear (aplicar-a x) fs) t)))
  +
  +(defun cadena-a-lista (cadena)
  +  (coerce cadena 'list))
  +
  +(defun lista-a-cadena (xs)
  +  (coerce xs 'string))
  +
  +(defun componer (f g)
  +    (lambda (x)
  +      (funcall g (funcall f x))))
  +
  +(defun palindromo (xs)
  +  (string-equal (lista-a-cadena xs) (lista-a-cadena (voltear xs))))
  +
  +(defun main ()
  +  (format t "Numeros divisibles entre 13 y el 7 del 1 al 1000:~%")
  +  (let ((divisor-13? (generar-divisor? 13))
  +	(divisor-7? (generar-divisor? 7)))
  +    (format t "~S~%"
  +	    (tomar-cuando (y-funciones divisor-13? divisor-7?)
  +			  (rango 1000))))
  +  (format t "Introduzca una palabra: ")
  +  (finish-output)
  +  (let* ((palabra (string-downcase (read-line)))
  +	 (xs (cadena-a-lista palabra)))
  +    (if (palindromo xs)
  +	(format t "Su palabra es un palindromo~%")
  +	(format t "Su palabra no es un palindromo~%")))
  +  
  +(main)
  
positive.code: (defun alguno? (f xs)
      (reducir #'o-logico (mapear f xs) nil))
  
  (defun tomar (n xs)
      (defun tomar-p (n xs ys)
          (let ((x (car xs))
                (rest (cdr xs)))
              (if x
                  (cond
                      ((> n 0) (tomar-p (- n 1) rest (append ys (list x))))
                      (t ys))
                  ys)))
      (tomar-p n xs '()))
  
  ;; Funcion de alto orden, regresa una funcion
  (defun anadir-verdad (f)
  
negative.code:     (let ((x (car xs))
            (rest (cdr xs)))
          (cond
              (x (append (voltear rest) (list x)))
              (t '()))))
  
  (defun alguno?-2 (f xs)
  