Iterar a través de un mapa con doseq

Question

Soy nuevo en Clojure y estoy haciendo algunas cosas básicas de labrepl, ahora quiero escribir una función que reemplace ciertas letras con otras letras, por ejemplo: elosska → elößkä.

me escribió esto:

(ns student.dialect (:require [clojure.string :as str])) 
(defn germanize 
    [sentence] 
    (def german-letters {"a" "ä" "u" "ü" "o" "ö" "ss" "ß"}) 
    (doseq [[original-letter new-letter] german-letters] 
    (str/replace sentence original-letter new-letter))) 

pero no funciona como espero. ¿Usted me podría ayudar por favor?

Answer 1

Aquí es mi opinión,

 

(def german-letters {"a" "ä" "u" "ü" "o" "ö" "ss" "ß"}) 

(defn germanize [s] 
    (reduce (fn[sentence [match replacement]] 
      (str/replace sentence match replacement)) s german-letters)) 

 

(germanize "elosska") 

Answer 2

Hay 2 problemas aquí:

1. doseq no conserva la cabeza de la lista que creó por su evaluación, por lo que no obtendrá ningún resultado
2. str/replace obras de copias separadas de texto, produciendo 4 resultados diferentes: puede verificar esto reemplazando doseq con for y obtendrá una lista con 4 entradas.

código podría reescribirse siguiente manera:

(def german-letters {"a" "ä" "u" "ü" "o" "ö" "ss" "ß"}) 
(defn germanize [sentence] 
    (loop [text sentence 
     letters german-letters] 
    (if (empty? letters) 
     text 
     (let [[original-letter new-letter] (first letters)] 
     (recur (str/replace text original-letter new-letter) 
       (rest letters)))))) 

En este caso, los resultados intermedios se recogen, por lo que todas las sustituciones se aplican a misma cadena, produciendo cadena correcta:

user> (germanize "elosska") 
"elößkä" 

PD tampoco se recomienda usar def en la función - es mejor usarlo para formularios de nivel superior

Answer 3

Alex ya ha respondido correctamente la pregunta con respecto al problema original usando doseq ... pero encontré la pregunta interesante y quería ver cómo sería una solución más "funcional". Y con eso quiero decir sin usar un bucle.

me ocurrió esto:

(ns student.dialect (:require [clojure.string :as str])) 

(defn germanize [sentence] 
    (let [letters {"a" "ä" "u" "ü" "o" "ö" "ss" "ß"} 
     regex (re-pattern (apply str (interpose \| (keys letters))))] 
    (str/replace sentence regex letters))) 

que produce el mismo resultado:

student.dialect=> (germanize "elosska") 
"elößkä" 

La línea regex (re-pattern... simplemente evalúa a #"ss|a|o|u", lo que habría sido más limpio y más fácil de leer, si ingresó como una cadena explícita, pero pensé que era mejor tener solo una definición de las letras alemanas.