Recursion dentro de la funcion de dejar

clojure let

Question

Estoy confundido en cuanto a cómo def y dejo variables de vinculación de manera diferente. ¿Puede alguien explicarme por qué esto funciona?

(def leven  
  (memoize (fn [x y]
  (cond (empty? x) (count y)
      (empty? y) (count x)
       :else (min (+ (leven (rest x) y) 1)
                  (+ (leven x (rest y)) 1)
                  (+ (leven (rest x) (rest y)) (if (= (first x) (first y)) 0 1))
              )
  )))
)

Pero cuando trato de declarar la función como deja que no compile:

(def leven  
    (let [l (memoize (fn [x y]
    (cond (empty? x) (count y)
          (empty? y) (count x)
           :else (min (+ (l (rest x) y) 1)
                      (+ (l x (rest y)) 1)
                      (+ (l (rest x) (rest y)) (if (= (first x) (first y)) 0 1))
                  )
    )
    ))]
    (l x y)
    )
)

EDITAR: Esto funciona, usando la técnica mostrada por Ankur.

(defn leven [x y] 
(let [l (memoize (fn [f x y]
(cond (empty? x) (count y)
      (empty? y) (count x)
       :else (min (+ (f f (rest x) y) 1)
                  (+ (f f x (rest y)) 1)
                  (+ (f f (rest x) (rest y)) (if (= (first x) (first y)) 0 1))
              )
)
))
magic (partial l l)]
(magic x y)
)
)

Answer 1

A continuación se muestra un ejemplo de cómo hacer lo que ha pedido. Estoy usando factorial solo por simplicidad y he imprimido en factorial para asegurarme de que la memorización funciona bien

(let [fact (memoize (fn [f x] 
                       (println (str "Called for " x))
                       (if (<= x 1) 1 (* x  (f f (- x 1))))))
      magic (partial fact fact)] 
     (magic 10)
     (magic 11))

Primero calcule el factorial de 10 y luego 11, en cuyo caso no debería volver a llamar factorial de 10 a 1 como se ha memorizado.

Called for 10
Called for 9
Called for 8
Called for 7
Called for 6
Called for 5
Called for 4
Called for 3
Called for 2
Called for 1
Called for 11
39916800

Answer 2

La forma let enlaza los nombres secuencialmente, por lo que en su segunda definición de función, el nombre l no existe cuando intenta hacer referencia a él. Puede usar letfn (con algunos mods menores) o darle un nombre a la función definida y en su lugar referirse a eso, así:

(def leven  
  (let [l (memoize (fn SOME-NAME [x y]
    (cond 
      (empty? x) (count y)
      (empty? y) (count x)
      :else (min (+ (SOME-NAME (rest x) y) 1)
                 (+ (SOME-NAME x (rest y)) 1)
                 (+ (SOME-NAME (rest x) (rest y)) (if (= (first x) (first y)) 0 1))))))]
l))

Como puedes notar, cambio el retorno del let to be l , ya que eso es lo que quieres leven . El (lxy) era problemático porque se refería a enlaces solo locales a la función y no accesibles para el let .