anchor.diff:      (let ((x (car xs))
             (rest (cdr xs)))
           (cond
  -            (x (append (list x) (voltear rest)))
  +            (x (append (voltear rest) (list x)))
               (t '()))))
   
   (defun alguno?-2 (f xs)
  
positive.code:         (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)))
  
  (defun igual-5 (a) (format t "~D~%" a) (= a 5))
  
  (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 '()))
  
negative.code: (defun alguno? (f xs)
      (reducir #'o-logico (mapear f xs) nil))
  
  (defun generar-agregar-tantos (n)
      (let ((contador 0))
          (defun agregar-tantos (xs a)
              (cond ((< contador n) 
                          (setq contador (+ contador 1))
                          (append xs (list a)))
                      (t xs)))))
  
  (defun tomar (n xs)
      (reducir (generar-agregar-tantos n) xs '()))
  
  ;; Funcion de alto orden, regresa una funcion
  (defun anadir-verdad (f)
  