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)))))

Comentarios

Aún no hay comentarios

Deja un comentario