2.20   LISP

Lisp (LISt Processing language) è stato sviluppato nel 1958 John McCarthy al Massachusetts Institute of Technology (MIT), nell'ambito delle ricerche sulla intelligenza artificiale.

Negli anni sono stati realizzati decine di versioni ed anche macchine i cui processori interpretavano direttamente il liguaggio. Molti dei dialetti del LISP sono derivati o ispirati al Maclisp, realizzato nel 1960 al MIT. Successivamente fu standardizzato il Common Lisp, mentre, sempre al MIT, Gerry Sussman e Guy Steele svilupparono Scheme, una versione semplificata di LISP.

LISP è orientato alla programmazione funzionale basata su strutture a lista; il primo elemento della lista è interpretato come funzione, e di conseguenza gli altri elementi ne diventano gli operandi. Di fatto le funzioni sono scritte in notazione infissa, e ciò permette di estendere funzioni normalmente binarie ad agire su più operandi: (* 5 7 6 8 9).

Le strutture di base del LISP sono le liste, liste come paradigma di una memoria non lineare, poiché ogni elemento di esse può contenere un "atomo" o una nuova lista. La realizzazione fisica di un elemento di una lista o cella è detto "cons", esso corrisponde ad un record con due campi, chiamati "car" e "cdr". I nomi derivano da "constructor" (nel senso di costruttore di lista) e dal nome di due registri del calcolatore IBM 704, sul quale fu costruito il primo LISP;  questi, Contents of Address Register e Contents of Decrement Register, puntano rispettivamente al primo elemento della lista e al resto della lista. Nell'esempio qui riportato, vi è l'estrazione della struttura di una lista gerarchizzata di oggetti, per poterne effettuare il grafico (v. 1.5.1)

;; emacs version 20.7.1

; (nodo (subnodo) (subnodo) ...)

(setq Frase '(Frase (SN (articolo nome) SV (verbo SN (articolo nome)))))

(defun view (lista)

  (setq level 0)

  (setq sublevel (make-vector 10 0))       ; progressivo elementi "fratelli"

  (vst lista))

 

(defun vst(lista)

     (if (equal (car lista) nil) t         ; fine

            (progn (if (atom (car lista)) 

                (progn

                (aset sublevel level (+ (aref sublevel level) 1))

                (print (format "%s %s" (make-string (* 3 level) ?\ )

                   (car lista)))

                (write-region

                  (format "%02d %02d %s\n" level (aref sublevel level)

                     (car lista)) nil "tree.txt" t)))

             (if (listp (car lista))      ; ci sono sottoliste

                (progn 

                (setq level (+ 1 level))

                (aset sublevel level 0)

                (vst (car lista))         ; estrae da sottolista

                (setq level (- level 1))))

             (if (listp (cdr lista))

                (vst (cdr lista))))))

L'esecuzione del programma è riportata nella tabella seguente:

Sessione di lavoro

Contenuto del file

(load "D:/fsf/lisp/tree.el")

t

(view Frase)

 

" Frase"

 

"    SN"

 

"       articolo"

 

"       nome"

 

"    SV"

 

"       verbo"

 

"       SN"

 

"          articolo"

 

"          nome"

t

00 01 Frase

01 01 SN

02 01 articolo

02 02 nome

01 02 SV

02 01 verbo

02 02 SN

03 01 articolo

03 02 nome

 

 

2.20.1       Precursori del LISP

IPL (Information Processing Language) linguaggio per il calcolatore JOHNNIAC (in onore di Jonh von Neumann) alla RAND Corporation, sviluppato da Nevell, Shaw e Simon. Con IPL fu costruito un programma per giocare a scacchi.

2.20.2       Dialetti del LISP

Flavors, costruito al MIT con il suo discendente Common Lisp Object System, CLOS, il primo linguaggio object oriented ad essere standardizzato.

Scheme una variante dovuta a Guy L. Steele e Gerald J. Sussmanin nel 1970, su sistema operativo ITS. Scheme ha poche primitive: il principale strumento di controllo del flusso è la tail recursion. È stata una delle prime varianti di LISP ad introdurre lo scoping lessicale delle variabili piuttosto che quello dinamico. 

MDL un dialetto con una ricca dotazione di strutture di dati.

CLU Barbara Liskov - MIT.

MACLisp sviluppato al MIT nell'ambito del progetto MAC.

ZetaLisp discendente del MACLisp, era l'interprete nativo delle Lisp machines, i calcolatori dedicati al LISP.

InterLisp sviluppato al MIT, successivamente adottato dalla XEROX per le sue Lisp Machines. InterLisp 65 una versione per Atari 6502, e anche InterLisp-D.

Franz Lisp in origine un progetto dell'università di Berkeley, successivamente supportato da Franz, Inc.

Common Lisp derivante da ZetaLisp ed in parte da Franz Lisp e InterLisp.

Gold Hill Common Lisp una implementazione per PC del Lisp.

Coral Lisp Lisp per il Macintosh.

Scheme un Lisp ridotto, inizialmente per scop didattici.].

AutoLisp linguaggio di scripting di AutoCAD.

Emacs Lisp liguaggio di scripting per l'editor Emacs; affine a MacLisp, con minori aspetti da Common Lisp.

Oak Lisp un Lisp object-oriented Lisp basato su Scheme.

Cambridge Lisp in origine sui mainframes IBM; prodotto da Metacomco per Amiga.

Guile un progetto GNU di implementazione di Scheme.