2010-03-08 6 views
10

Me preguntaba si existe una práctica estándar con respecto al uso de etiquetas en Lisp. He estado jugando con una implementación de Lisp del algoritmo descrito en la primera respuesta aquí Generating permutations lazily Mi versión actual usa etiquetas para separar partes de la funcionalidad.Lisp Style question label funciones locales o no?

(defun next-permutation (pmute) 
    (declare (vector pmute)) 
    (let ((len (length pmute))) 
    (if (> len 2) 
     (labels ((get-pivot() 
        (do ((pivot (1- len) (1- pivot))) 
         ((or (= pivot 0) 
          (< (aref pmute (1- pivot)) 
           (aref pmute pivot))) 
         pivot))) 
       (get-swap (pivot) 
        (let ((swp (1- len))) 
        (loop for i from (1- len) downto pivot do 
          (if (or (and (> (aref pmute i) 
              (aref pmute (1- pivot))) 
             (< (aref pmute i) (aref pmute swp))) 
            (< (aref pmute swp) (aref pmute (1- pivot)))) 
           (setf swp i))) 
        swp)) 
       (next (swp pivot) 
        (rotatef (aref pmute (1- pivot)) (aref pmute swp)) 
        (reverse-vector pmute pivot (1- len)))) 
      (let ((piv (get-pivot))) 
      (if (> piv 0) 
       (next (get-swap piv) piv) 
       nil)))))) 

Como cada etiqueta sólo se llama una vez me preguntaba si esto se considera una mala práctica ya que la única razón para hacerlo en este caso es por razones estéticas. Yo diría que la versión actual con etiquetas es más clara, pero eso puede ir en contra de la sabiduría común de la que no tengo conocimiento, siendo nuevo para Lisp.

+1

Puede usar 'flet' en lugar de' labels' si sus funciones no necesitan referirse entre ellas (ni a ellas mismas). – Svante

+0

¿Hay alguna ventaja de hacer esto además de comunicar ese poco de información extra a cualquier persona que lea el código? – asm

+0

Probablemente no. Sin embargo, recuerde que debe escribir el código para la siguiente persona que lea el código, el compilador/intérprete no es su audiencia principal. – Vatine

Respuesta

7

No, está bien. Escribir funciones nombradas hace que el código sea un poco más autodocumentado y más modular.

A veces también enumeraría todas las variables utilizadas en las funciones arglist y no usaría las variables de la función adjunta. Eso hace que la interfaz sea un poco más clara y ayuda a mover la función en el código (si es necesario).

Las funciones locales también ofrecen la posibilidad de agregar cadenas de documentación local y descripciones de interfaz.

Si las funciones locales son demasiado grandes y también pueden usarse en el exterior, las extraeré y convertiré en globales.

1

No siendo nada más que un novato de Lisp, diría que estás haciendo lo correcto: hacer que tu código sea más legible nombrando fragmentos.

2

No veo nada malo con eso. Está haciendo que los dos subprocesos sean muy claros y fáciles de cortar, lo que facilita obtener una idea rápida de lo que realmente es la función al mirar el cuerpo. Además, ahora es fácil promover las funciones internas a funciones globales si es necesario.

Cuestiones relacionadas