Lisp, förkortning för "LISt Processing," är en familj av programmeringsspråk som delar en distinkt syntax baserad på parenteser, främst centrerad kring manipulation av symboler och listor. Det är ett av de äldsta hög-nivå programmeringsspråken, ursprungligen uppfunnet i slutet av 1950-talet, och har utvecklats avsevärt under årtiondena. Lisp är särskilt känt för sina kraftfulla funktioner som dynamisk typning, skräpsamling och förstklassiga funktioner, vilket gör det lämpligt för AI-forskning, symbolisk beräkning och snabb prototypframställning.
Lisp skapades av John McCarthy 1958 som en matematisk notation för datorprogram och som ett praktiskt medel för att implementera AI. Språket härstammar från lambda-kalkyl, ett formellt system inom matematisk logik och datavetenskap. Den första implementationen genomfördes på IBM 704, och snart därefter uppstod många dialekter, var och en med sina egna funktioner och komplexiteter.
Flera anmärkningsvärda dialekter av Lisp har uppstått över tid, inklusive Common Lisp och Scheme. Common Lisp standardiserades på 1980-talet för att förena olika dialekter, medan Scheme, som betonar funktionell programmering och minimalism, fick popularitet inom akademin. Lisp-influenser kan ses i många moderna programmeringsspråk, särskilt de som stödjer funktionella programmeringsparadigm, såsom Clojure, Racket och till och med språk som Python och Ruby.
Idag är Lisp inte bland de mest populära programmeringsspråken men förblir inflytelserikt, särskilt inom forskning, AI och utbildning. Gemenskapen utvecklar aktivt nyare dialekter som Clojure, som körs på Java Virtual Machine (JVM) och fokuserar på samtidig programmering.
Lisp använder en unik syntax med parenteser för att ange uttryck, där kod representeras i symboliska uttryck (S-uttryck). Till exempel:
(+ 1 2)
Detta uttryck representerar additionen av 1 och 2.
Funktioner i Lisp kan skickas som argument, returneras från andra funktioner och tilldelas variabler:
(defun square (x) (* x x))
(mapcar #'square '(1 2 3 4)) ; returnerar (1 4 9 16)
Lisp är dynamiskt typat, vilket gör att variabler kan hålla värden av vilken datatyp som helst utan föregående deklaration:
(setq x 10) ; x är nu ett nummer
(setq x "hello") ; x är nu en sträng
Lisp har kraftfulla makrosystem som gör att utvecklare kan skapa egna syntaktiska konstruktioner:
(defmacro when (condition &body body)
`(if ,condition
(progn ,@body))
)
if och cond former underlättar kontrollflödet i Lisp:
(if (> x 0)
(print "Positiv")
(print "Icke-positiv"))
Lisp behandlar listor som grundläggande datastrukturer:
(setq my-list '(1 2 3 4))
(car my-list) ; returnerar 1
(cdr my-list) ; returnerar (2 3 4)
Funktioner definieras med hjälp av defun konstruktionen:
(defun factorial (n)
(if (= n 0)
1
(* n (factorial (- n 1)))))
Common Lisp inkluderar ett objektorienterat system känt som Common Lisp Object System (CLOS):
(defclass person ()
((name :initarg :name :accessor person-name)
(age :initarg :age :accessor person-age)))
(defmethod say-hello ((p person))
(format t "Hej, jag heter ~A och jag är ~A år gammal."
(person-name p) (person-age p)))
Lisp tillhandahåller en sofistikerad felhanteringsmekanism med handler-case:
(handler-case
(/ 1 0)
(division-by-zero () (print "Fångade division med noll!")))
Fortsättningar stöds i vissa dialekter, vilket gör att programmet kan spara och återställa exekveringstillstånd:
(call-with-current-continuation
(lambda (k)
(k 10)))
Flera integrerade utvecklingsmiljöer (IDE:er) och kompilatorer är anpassade för Lisp-programmering. Populära val inkluderar:
För att bygga ett Lisp-projekt skapar du vanligtvis en fil med en ".lisp" eller ".lsp" filändelse. Med SBCL kan ett typiskt arbetsflöde involvera att ladda ditt projekt från REPL:
(load "my-project.lisp")
För projekt som använder Quicklisp, en bibliotekshanterare, kan beroenden enkelt hanteras och laddas.
Lisp är särskilt känt för sina tillämpningar inom artificiell intelligens, symbolisk beräkning och akademi, men det används också inom:
Lisp jämförs ofta med:
Översättning från Lisp till andra språk görs ofta med hjälp av käll-till-käll översättningsverktyg. Till exempel finns följande verktyg:
Varje av dessa verktyg tillhandahåller specifika mappningar som säkerställer att kärnfunktionaliteterna i Lisp kan representeras effektivt i målspråken. För mer komplexa översättningar kan manuell omstrukturering krävas, särskilt för kraftigt makro-optimerad kod.