Create a gist now

Instantly share code, notes, and snippets.

@nihilismus /fos.clj
Last active May 20, 2016

Embed
What would you like to do?
Funciones de Orden Superior y Funciones Sobre Colecciones en Clojure haciendo uso de recursividad (first, rest y conj)
(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)))))
; 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))))
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment