In quale ordine devono essere definite le funzioni lisp?

Per Common Lisp sto usando qualcosa del genere:

I file
• sono organizzati in sistemi e sottosistemi (vedi ad esempio ASDF come strumento per quello)
• puoi mettere tutto in un unico file, ma ciò richiede un po 'di attenzione
• pezzi più grandi di Lisp sono organizzati in sistemi di file (vedi sopra) e di solito sono compilati con il compilatore di file
• utilizzando compile-file , un file è una unità di compilazione

File in un sistema :

1. dichiarazioni di sistema
2. dichiarazione / i del pacchetto
3. funzioni di utilità
4. Macro
5. classi
6. codice vario
7. macchina / os / codice specifico di implementazione
8. un sistema per i test

un sottosistema in un file:

1. intestazione dell'editor (modalità, pacchetto, dialetto, codifica del testo, base, ...)
2. copyright, licenza
3. descrizione dello scopo e dell'uso
4. utilizzando quale pacchetto
5. vars / dati globali di configurazione
6. costanti
7. classi principali
8. condition classes
9. macro e il loro codice di supporto
10. funzioni / metodi / funzioni generiche
11. esempi

Se sviluppi, carichi il sistema compilato sviluppato finora e lo estendi in modo incrementale. Una volta che una nuova funzionalità è stata scritta e testata - > compilare nuovamente il sistema, caricarlo e testarlo di nuovo.

Il vecchio libro "Lisp: Style and Design" di Molly M. Miller e Eric Benson descrive i principi organizzativi e fornisce un esempio. Dato che questo libro è vecchio, ci sono alcune nuove infrastrutture e alcuni nuovi strumenti. Ma i principi generali citati nel libro sono ancora utili.

Common Lisp ha sia COMPILE e COMPILE-FILE .

Un'implementazione come SBCL non avvisa della funzione indefinita se si compila l'intero file, ad esempio. Sotto la melma, C-c M-k non fa scattare un avvertimento:

(defun bar (x) (foo x))
(defun foo (y) (+ 3 y))

Una volta compilato, il caricamento di .fasl in una nuova immagine Lisp non dà alcun preavviso, sebbene il caricamento di .lisp lo faccia, perché LOAD per un file sorgente è sufficiente eseguire tutti i moduli in sequenza.

Tuttavia, la maggior parte del codice che ho visto definisce elementi da elementi di basso livello e crea funzioni di livello superiore più avanti nel file. Non trovo più confusionario in questo ordine che nel contrario, personalmente. È abbastanza coerente con il modo in cui definisci le funzioni locali con flet o labels , o anche con variabili locali con let . Se è necessario definire le funzioni reciprocamente ricorsive, è anche possibile dichiarare le proprie funzioni prima di definirle:

(declaim (ftype function foo bar baz ...))

L'ambiente Lisp supporta metodi efficienti per la definizione di funzioni e metodi, quindi in genere mi baso più su slime-edit-definition .

Ciò che importa più IMO per organizzare il tuo codice è probabilmente pensare ai pacchetti e al modo in cui si relazionano tra loro.