defn vs. let respecto a la descomposición

Question

Defino una función, que toma dos parámetros: mapa y una clave. La clave se hace referencia a partir de la descomposición de parámetros mapa

(defn myfunc [{v k} k] 
    v) 

cuando llamo:

(myfunc {:a 10} :a) 

Sorprendentemente produce esperado resultado: 10

cosa similar en el let:

(let [{v k} {:a 10} k :a] v) 

falla, porque k no está definido en momento, cuando se evalúa la primera parte

Mi pregunta es: ¿por qué la descomposición dentro de los parámetros de función se comporta de manera diferente en comparación con la descomposición en let expresiones?

Answer 1

Macroexpanding forma defn consigo el equivalente de esta (cosas .withMeta eliminado y volver a formatear):

(def myfunc 
    (fn* myfunc 
     ([p__11393 k] 
      (let* [map__11394 p__11393 
       map__11394 (if (seq? map__11394) 
           (apply hash-map map__11394) 
           map__11394) 
       v   (get map__11394 k)] 
       v)))) 

Así que aquí podemos ver que el mapa {v k} es, de hecho, la primera asignada a una variable local p__11393. Luego, la declaración if prueba si esa variable es de hecho una secuencia y la convierte en un hash-map si es así, de lo contrario la deja tal como está. Es importante destacar que el valor asignado a k se busca en el mapa después de todo esto sucede, por lo tanto, esto funciona sin error (y también si :a no estaba en el mapa, get devuelve nil en ese caso).

Por otro lado macroexpanding forma let me sale

(let* 
    [map__11431 
    {:a 10} 
    map__11431 
    (if (seq? map__11431) (apply hash-map map__11431) map__11431) 
    v 
    (get map__11431 k) 
    k 
    :a] 
    v) 

y aquí podemos ver que v obtiene el resultado de (get map__11431 k), pero k no está definido en este punto, sin embargo, de ahí el error.

Answer 2

Ésta no es una respuesta completa, pero el siguiente sí funciona:

user=> (defn myfunc [{v k} k] v) 
#'user/myfunc 
user=> (myfunc {:a 10} :a) 
10 
user=> (let [k :a {v k} {:a 10}] v) 
10 
user=>