conj - Orden del código en Clojure

map clojure

Question

Tengo un problema simple pero frustrante en Clojure, tengo una función (llamémosla función de lectura) que calcula lo que el usuario quiere hacer desde su entrada y luego llama a otra función que hace eso (llamémoslo acción-función). Esta función de acción llama a la función de lectura cuando está lista para que el usuario pueda realizar otra tarea.

Ahora mi problema es que si puse el código para la función de lectura antes del código de acción-función, aparece un error en la función de lectura que dice que no sabe qué función-acción es (porque el código para ello está más allá abajo) y si hago lo opuesto, bueno, obviamente obtengo un error similar, diciendo que la función de lectura no se puede resolver, etc.

¿Hay una manera simple de arreglar esto?

El código real:

(defn ajout [botin]
  (def botin botin)
  (readCmd botin)
)

(defn readCmd [botin]
  (println "Entrez une commande svp ")
  (def botin botin)
  (let [cmd (read-line)]
    (if (.equals cmd "a") ((println "Ajout 8o") (ajout botin))
      (if (.equals cmd "e") ((println "Elim 8o") (eliminer botin))
        (if (.equals cmd "i") ((println "Imprim 8o") (imprimer botin))
          ((println "Commande invalide, nous vous rapellons que les commandes possibles sont : ") (print-les-cmd) (readCmd))))))


)

así, obtengo un error en la línea (readCmd botin) en la función ajout que dice: No se puede resolver el símbolo: readCmd en este contexto

Si pongo el código para estas dos funciones en el orden inverso obtendré un error que dice: No se puede resolver el símbolo: ajout en este contexto

Answer 1

Como los demás ya respondieron, necesita (declarar readCmd) para solucionar su problema inmediato.

Sin embargo, todavía hay problemas con este código, ya que implementa un proceso iterativo mediante la recursión mutua (readCmd -> ajout -> readCmd -> imprimer -> readCmd -> ...) que consumirá la pila y obtendrá ( encendido) desbordamiento de la pila. Una mejor forma de organizar esto sería hacer que readCmd sea recursivo y hacer que llame a las acciones. Cuando una acción retorna, readCmd tail recursivamente se llama a sí mismo.

También este fragmento de código:

((println "Ajout 8o") (ajout botin))

probablemente no sea lo que quieres hacer: llamará a println y tratará de usar el resultado como una función. Use "do" en su lugar:

(do (println "Ajout 8o") (ajout botin))

También puede considerar leer sobre caso o cond, simplificarán los ifs anidados.

Otra cosa extraña sobre tu código es

(def botin botin)

¿De qué trata?

Answer 2

En la parte superior de tu código pon:

(declare readCmd)

Answer 3

Hay un hilo en el grupo de google de Clojure sobre esto que ofrece algunas consideraciones interesantes, en particular sobre cómo el uso de declare puede hacer que algunas herramientas del ecosistema se vean afectadas:

thread

Por supuesto, podría argumentar que las buenas herramientas deberían funcionar con todas las construcciones del lenguaje :)

OMI, te acostumbras al estilo ascendente y acabas de leer al revés. Es una historia un poco diferente tu historia donde construyes cosas en lugar de descomponerlas.

Y, por supuesto, como han dicho otros, puede reenviar declarar con

(declare my-function)

Answer 4

Puede usar declaraciones avanzadas en Clojure para que pueda llamar a funciones que aún no se han definido.

(declare readCmd)

¡Deberia trabajar!

En Clojure, el orden en que se definen las funciones es importante, una función no puede llamar a otra función (o cualquier cosa para el caso) que aún no se haya definido. Es por eso que tenemos declaraciones avanzadas.