Iteraciones de orden superior sobre listas

1. reduce: Aplica una función a pares de elementos de una lista hasta dejarla en un solo valor.
   (defun reduce (f l base)
   (if (endp l)
   base
   (funcall f (car l) (reduce f (cdr l) base))))

   
   

2. map: Aplica una función a cada elemento de una lista y devuelve una lista con el resultado de aplicar la función a cada elemento.
   (defun map (f l)
   (if (endp l)
   nil
   (cons (funcall f (car l)) (map f (cdr l)))))

   
   

3. accumulate: Practicamente igual a reduce. Es recursión de cola, por lo que es mas eficiente que reduce.
   (defun accumulate (f l acum)
   (if (endp l)
   acum
   (accumulate f (cdr l) (funcall f acum (car l)))))

   
   

4. filter: Verifica que los elementos de una lista cumplan una determinada condición, devolviendo los elementos que cumplen esa condición.
   (defun filter (p l)
   (if (endp l)
   nil
   (if (funcall p (car l))
   (cons (car l) (filter p (cdr l)))
   (filter p (cdr l)))))

   
   

5. exists: Devuelve el primer elemento de la lista que verifique una determinada condición o falso si ninguna la cumple.
   (defun exists (p l)
   (if (endp l)
   nil
   (if (funcall p (car l))
   (car l)
   (exists p (cdr l)))))

   
   

6. for-all: Devuelve true si todos los elementos de una lista cumplen una determinada condición.
   (defun for-all (p l)
   (if (endp l)
   t
   (if (funcall p (car l)) (for-all p (cdr l)) nil)))

   
   

7. zip: Toma dos listas de igual longitud y devuelve la lista cuyo enésimo elemento es el resultado de aplicar la función pasada como parámetro a el elemento enésimo de cada lista.
   (defun zip (f l1 l2)
   (if (endp l1)
   nil
   (cons (funcall f (car l1) (car l2)) (zip f (cdr l1) (cdr l2)))))