Funciones de Orden Superior y Funciones Sobre Colecciones en Clojure haciendo uso de recursividad (first, rest y conj)

fos.clj

(def lmap (fn [f xs]
            (letfn [(g ;; Función Recursiva (FR): recorre la LO para regresar la LA conformada con los resultados
                       ;;                         obtenidos de aplicar la FA sobre cada E en la LO.
                       ;; Elemento (E): es cada valor (val) en la LO
                       ;;               '(valor1 valor2 valorN)
                      [ys ;; Lista Original (LO) o Lista de Entrada (LE)
                       zs ;; Lista de Acumulación (LA) o Lista de Salida (LS)
                       h  ;; Función a Aplicar (FA)
                       ]
                      (if (nil? (first ys))
                        zs
                        (g (rest ys) (conj zs (h (first ys))) h)))]
              (g (g xs '() (fn [x] x)) '() f))))

(def vmap (fn [f xs]
            (letfn [(g ;; Función Recursiva (FR): recorre el VO para regresar el VA conformado con los resultados
                       ;;                         obtenidos de aplicar la FA sobre cada E en el VO.
                       ;; Elemento (E): es cada valor (val) en el VO
                       ;;               [valor1 valor2 valorN]
                      [ys ;; Vector Original (VO) o Vector de Entrada (VE)
                       zs ;; Vector de Acumulación (VA) o Vector de Salida (VS) 
                       h  ;; Función a Aplicar (FA)
                       ]
                      (if (nil? (first ys))
                        zs
                        (g (rest ys) (conj zs (h (first ys))) h)))]
              (g xs [] f))))

(def mmap (fn [f xs]
            (letfn [(g ;; Función Recursiva (FR): recorre el MO para regresar el MA conformado con los resultados
                       ;;                         obtenidos de aplicar la FA sobre cada val por cada E en el VO,
                       ;;                         respetando cada lla en E.
                       ;; Elemento (E): es cada par llave-valor (lla-val) en el MO,
                       ;;               {llave1 valor1 llave2 valor2 llaveN valorN}
                      [ys ;; Mapa Original (MO) o Mapa de Entrada (ME)
                       zs ;; Mapa de Acumulación (MA) o Mapa de Salida (MS)
                       h  ;; Función a Aplicar (FA)
                       ]
                      (if (nil? (first ys))
                        zs
                        (g (rest ys)
                           (conj zs [ ((first ys) 0) (h ((first ys) 1)) ])
                           h)))]
              (g xs {} f))))

(def cmap (fn [f xs]
            (letfn [(g ;; Función Recursiva (FR): recorre la LO para regresar la LA conformada con los resultados
                       ;;                         obtenidos de aplicar FA sobre cada E en la LO.
                       ;; Elemento (E): es cada valor (val) en el CE,
                       ;;               #{valor1 valor2 valorN}
                      [ys ;; Conjunto Original (CO) o Conjunto de Entrada (CE)
                       zs ;; Conjunto de Acumulación (CA) o Conjunto de Salida (CS)
                       h  ;; Función a Aplicar (FA)
                       ]
                      (if (nil? (first ys))
                        zs
                        (g (rest ys) (conj zs (h (first ys))) h)))]
              (g xs #{} f))))

(def smap (fn [f xs]
            (letfn [(g ;; Función Recursiva (FR): recorre la CCO para regresar la CCA conformada con los resultados
                       ;;                         obtenidos de aplicar la FA sobre cada E en la CCO.
                       ;; Elemento (E): es cada caracter (car) en la CCO
                       ;;               "car1car2carN"
                      [ys ;; Cadena de Caracteres Original (CCO) o Cadena de Caracteres de Entrada (CCE) 
                       zs ;; Cadena de Caracteres de Acumulación (CCA) o Cadena de Caracteres de Salida (CCS)
                       h  ;; Función a Aplicar (FA)
                       ]
                      (if (nil? (first ys))
                        zs
                        (g (rest ys) (str zs (h (first ys))) h)))]
              (g xs "" f))))

(def lfilter (fn [f xs]
               (letfn [(g ;; Función Recursiva (FR): recorre la LO aplicando el P sobre cada E, regresando la LA con
                          ;;                         los E para con los cuales P regresó true
                          ;; Elemento (E): es cada valor (val) en la LO
                          ;;               '(valor1 valor2 valorN)
                         [ys ;; Lista Original (LO) o Lista de Entrada (LE)
                          zs ;; Lista de Acumulación (LA) o Lista de Salida (LS)
                          h  ;; Función a Aplicar (FA) o Predicado (P)
                          ]
                         (if (nil? (first ys))
                           zs
                           (g (rest ys)
                              (if (h (first ys))
                                (conj zs (first ys))
                                zs)
                              h)))]
                 (g (g xs '() (fn [x] x)) '() f))))

(def vfilter (fn [f xs]
               (letfn [(g;; Función Recursiva (FR): recorre el VO aplicando el P sobre cada E, regresando el VA con
                          ;;                         los E para con los cuales P regresó true
                          ;; Elemento (E): es cada valor (val) en el VO
                          ;;               [valor1 valor2 valorN]
                         [ys ;; Vector Original (VO) o Vector de Entrada (VE)
                          zs ;; Vector de Acumulación (VA) o Vector de Salida (VS)
                          h  ;; Función a Aplicar (FA) o Predicado (P)
                          ]
                         (if (nil? (first ys))
                           zs
                           (g (rest ys)
                              (if (h (first ys))
                                (conj zs (first ys))
                                zs)
                              h)))]
                 (g xs [] f))))

(def mfilter (fn [f xs]
               (letfn [(g ;; Función Recursiva (FR): recorre el MO aplicando el P sobre cada E, regresando el MA con
                          ;;                         los E para con los cuales P regresó true
                          ;; Elemento (E): es cada par llave-valor (lla-val) en el MO
                          ;;               {llave1 valor1 llave2 valor2 llaveN valorN}
                         [ys ;; Mapa Original (MO) o Mapa de Entrada (VE)
                          zs ;; Mapa de Acumulación (MA) o Mapa de Salida (MS)
                          h  ;; Función a Aplicar (FA) o Predicado (P)
                          ]
                         (if (nil? (first ys))
                           zs
                           (g (rest ys)
                              (if (h ((first ys) 1))
                                (conj zs [ ((first ys) 0) ((first ys) 1) ])
                                zs)
                              h)))]
                 (g xs {} f))))

(def cfilter (fn [f xs]
               (letfn [(g ;; Función Recursiva (FR): recorre el CO aplicando el P sobre cada E, regresando el CA con
                          ;;                         los E para con los cuales P regresó true
                          ;; Elemento (E): es cada valor (val) en el CO
                          ;;               #{valor1 valor2 valorN}
                         [ys ;; Conjunto Original (CO) o Conjunto de Entrada (CE)
                          zs ;; Conjunto de Acumulación (CA) o Conjunto de Salida (CS)
                          h  ;; Función a Aplicar (FA) o Predicado (P)
                          ]
                         (if (nil? (first ys))
                           zs
                           (g (rest ys)
                              (if (h (first ys))
                                (conj zs (first ys))
                                zs)
                              h)))]
                 (g xs #{} f))))

(def sfilter (fn [f xs]
               (letfn [(g ;; Función Recursiva (FR): recorre la CCO aplicando el P sobre cada E, regresando la CCA con
                          ;;                         los E para con los cuales P regresó true
                          ;; Elemento (E): es cada caracter (car) en la CCO
                          ;;               "car1car2carN"
                         [ys ;; Cadena de Caracteres Original (CCO) o Cadena de Caracteres de Entrada (CCE) 
                          zs ;; Cadena de Caracteres de Acumulación (CCA) o Cadena de Caracteres de Salida (CCS)
                          h  ;; Función a Aplicar (FA) o Predicado (P)
                          ]
                         (if (nil? (first ys))
                           zs
                           (g (rest ys)
                              (if (h (first ys))
                                (str zs (first ys))
                                zs)
                              h)))]
                 (g xs "" f))))

(def lreduce (fn [f
                  vi ;; Valor Inicial (VI): valor a partir del cual se inicia la reducción. En g es conocido como VF.
                  xs]
               (letfn [(g ;; Función Recursiva (FR): recorre la LO para regresar el VF de las aplicaciones
                          ;;                         de FA sobre VI y un E en la LO
                          ;; Elemento (E): es cada valor (val) en la LO
                          ;;               '(valor1 valor2 valorN)
                       [ys ;; Lista Original (LO) o Lista de Entrada (LE)
                        vf ;; Valor Final (VF) o Valor de Salida (VS)
                        h  ;; Función a Aplicar (FA)
                        ]
                         (if (nil? (first ys))
                           vf
                           (g (rest ys) (h vf (first ys)) h)))]
                 (g xs vi f))))

(def vreduce (fn [f
                  vi ;; Valor Inicial (VI): valor a partir del cual se inicia la reducción. En g es conocido como VF.
                  xs]
               (letfn [(g ;; Función Recursiva (FR): recorre el VO para regresar el VF de las aplicaciones
                          ;;                         de FA sobre VI y un E en VO
                          ;; Elemento (E): es cada valor (val) en el VO
                          ;;               [valor1 valor2 valorN]
                       [ys ;; Vector Original (VO) o Vector de Entrada (VE)
                        vf ;; Valor Final (VF) o Valor de Salida (VS)
                        h  ;; Función a Aplicar (FA)
                        ]
                         (if (nil? (first ys))
                           vf
                           (g (rest ys) (h vf (first ys)) h)))]
                 (g xs vi f))))

(def mreduce (fn [f
                  vi ;; Valor Inicial (VI): valor a partir del cual se inicia la reducción. En g es conocido como VF.
                  xs]
               (letfn [(g ;; Función Recursiva (FR): recorre el MO para regresar el VF de las aplicaciones
                          ;;                         de FA sobre VI y un E en el MO
                          ;; Elemento (E): es cada par llave-valor (lla-val) en el MO
                          ;;               {llave1 valor1 llave2 valor2 llaveN valorN}
                       [ys ;; Mapa Original (MO) o Mapa de Entrada (ME)
                        vf ;; Valor Final (VF) o Valor de Salida (VS)
                        h  ;; Función a Aplicar (FA)
                        ]
                         (if (nil? (first ys))
                           vf
                           (g (rest ys) (h vf (first ys)) h)))]
                 (g xs vi f))))

(def creduce (fn [f
                  vi ;; Valor Inicial (VI): valor a partir del cual se inicia la reducción. En g es conocido como VF.
                  xs]
               (letfn [(g ;; Función Recursiva (FR): recorre el CO para regresar el VF de las aplicaciones
                          ;;                         de FA sobre VI y un E en el CO
                          ;; Elemento (E): es cada valor (val) en el CO
                          ;;               #{valor1 valor2 valorN}
                       [ys ;; Conjunto Original (CO) o Conjunto de Entrada (CE)
                        vf ;; Valor Final (VF) o Valor de Salida (VS)
                        h  ;; Función a Aplicar (FA)
                        ]
                         (if (nil? (first ys))
                           vf
                           (g (rest ys) (h vf (first ys)) h)))]
                 (g xs vi f))))

(def sreduce (fn [f
                  vi  ;; Valor Inicial (VI): valor a partir del cual se inicia la reducción. En g es conocido como VF.
                  xs]
               (letfn [(g ;; Función Recursiva (FR): recorre la CCO para regresar el VF de las aplicaciones
                          ;;                         de FA sobre VI y un E en la CCO
                          ;; Elemento (E): es cada caracter (car) en la CCO
                          ;;               "car1car2carN"
                         [ys ;; Cadena de Caracteres Original (CCO) o Cadena de Caracteres de Entrada (CCE) 
                          vf ;; Valor Final (VF) o Valor de Salida (VS)
                          h  ;; Función a Aplicar (FA)
                          ]
                         (if (nil? (first ys))
                           vf
                           (g (rest ys) (h vf (first ys)) h)))]
                 (g xs vi f))))

(def fncomp (fn [g f]
              (fn [
                   x ;; Valor de Entrada: es aplicado con f y el resultado dado aplicado con g.
                   ]
                (g (f x)))))

fsc.clj

; Inserta al inicio de xs a x
(def lconjf (fn [xs x]
              ; xs = una lista
              ; x  = elemento a insertar al inicio
              (conj xs x)))

; Inserta al final de xs a x
(def lconjl (fn [xs x]
              ; xs = una lista
              ; x  = elemento a insertar al final
              (letfn [(g [ys zs]
                        (if (nil? (first ys))
                          zs
                          (g (rest ys) (conj zs (first ys)))))]
                (g (conj (g xs '()) x) '()))))

; Inserta al inicio de xs a x
(def vconjf (fn [xs x]
              ; xs = un vector
              ; x  = elemento a insertar al inicio
              (letfn [(g [ys zs]
                        (if (nil? (first ys))
                          zs
                          (g (rest ys) (conj zs (first ys)))))]
                (g (g (lconjl (g xs '()) x) '()) []))))

; Inserta al final de xs a x
(def vconjl (fn [xs x]
              ; xs = un vector
              ; x  = elemento a insertar al final
              (conj xs x)))

; Convierte una lista en un vector
(def ltov (fn [xs]
            (letfn [(g [ys zs]
                      (if (nil? (first ys))
                        zs
                        (g (rest ys) (conj zs (first ys)))))]
              (g xs []))))

; Convierte un vector en una lista
(def vtol (fn [xs]
            (letfn [(g [ys zs]
                      (if (nil? (first ys))
                        zs
                        (g (rest ys) (conj zs (first ys)))))]
              (g (g xs '()) '()))))

; Convierte un vector en un mapa
(def vtom (fn [xs]
            (letfn [(g [ys zs indice]
                      (if (nil? (first ys))
                        zs
                        (g (rest ys) (conj zs [indice (first ys)]) (inc indice))))]
              (g xs {} 0))))