Lisp, kort for "LISt Processing," er ein familie av programmeringsspråk som deler ein karakteristisk parentesbasert syntaks, hovudsakleg sentrert rundt manipulering av symbol og lister. Det er eit av dei eldste høgnivå programmeringsspråka, oppfunne på slutten av 1950-talet, og det har utvikla seg betydelig gjennom tiåra. Lisp er spesielt kjent for sine kraftige funksjonar som dynamisk typing, søppelrydding og førsteklasses funksjonar, noko som gjer det eigna for AI-forskning, symbolsk berekning og rask prototyping.
Lisp vart oppretta av John McCarthy i 1958 som ein matematisk notasjon for dataprogram og som eit praktisk middel for å implementere AI. Språket vart avleidd frå lambda-kalkulus, eit formelt system innan matematisk logikk og datavitenskap. Den første implementasjonen vart utført på IBM 704, og kort tid etter dukka det opp mange dialektar, kvar med sine eigne funksjonar og kompleksitetar.
Flere bemerkelsesverdige dialektar av Lisp har dukka opp over tid, inkludert Common Lisp og Scheme. Common Lisp vart standardisert på 1980-talet for å samle ulike dialektar, medan Scheme, som legg vekt på funksjonell programmering og minimalisme, fekk popularitet i akademia. Lisp-influenser kan sjåast i mange moderne programmeringsspråk, spesielt dei som støttar funksjonelle programmeringsparadigmer, som Clojure, Racket, og til og med språk som Python og Ruby.
I dag er ikkje Lisp blant dei mest populære programmeringsspråka, men det er framleis innflytelsesrikt, spesielt innan forskning, AI og utdanning. Fellesskapet utviklar aktivt nyare dialektar som Clojure, som køyrer på Java Virtual Machine (JVM) og fokuserer på parallell programmering.
Lisp nyttar ein unik syntaks som bruker parentesar for å betegne uttrykk, med kode representert i symbolske uttrykk (S-uttrykk). For eksempel:
(+ 1 2)
Dette uttrykket representerer summen av 1 og 2.
Funksjonar i Lisp kan bli sende som argument, returnert frå andre funksjonar, og tildelt til variablar:
(defun square (x) (* x x))
(mapcar #'square '(1 2 3 4)) ; returnerer (1 4 9 16)
Lisp er dynamisk typa, noko som tillèt variablar å halde verdiar av kva som helst datatype utan føregåande erklæring:
(setq x 10) ; x er no eit tal
(setq x "hello") ; x er no ein streng
Lisp har kraftige makrosystem som tillèt utviklarar å lage tilpassa syntaktiske konstruksjonar:
(defmacro when (condition &body body)
`(if ,condition
(progn ,@body))
)
if og cond formene legg til rette for kontrollflyt i Lisp:
(if (> x 0)
(print "Positiv")
(print "Ikkje-positiv"))
Lisp behandlar lister som grunnleggjande datastrukturar:
(setq my-list '(1 2 3 4))
(car my-list) ; returnerer 1
(cdr my-list) ; returnerer (2 3 4)
Funksjonar blir definerte ved hjelp av defun konstruksjonen:
(defun factorial (n)
(if (= n 0)
1
(* n (factorial (- n 1)))))
Common Lisp inkluderer eit objektorientert system kjent 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 "Hei, eg heiter ~A og eg er ~A år gammal."
(person-name p) (person-age p)))
Lisp tilbyr ein sofistikert feilhåndteringsmekanisme ved hjelp av handler-case:
(handler-case
(/ 1 0)
(division-by-zero () (print "Fanga deling med null!")))
Fortsetjingar blir støtta i nokre dialektar, noko som tillèt programmet å lagre og gjenopprette utføringsstatar:
(call-with-current-continuation
(lambda (k)
(k 10)))
Flere integrerte utviklingsmiljø (IDEar) og kompilatorar er tilgjengelege for Lisp-programmering. Populære val inkluderer:
For å bygge eit Lisp-prosjekt, opprettar du vanlegvis ein fil med ".lisp" eller ".lsp" utviding. Ved bruk av SBCL kan ein typisk arbeidsflyt involvere å laste prosjektet frå REPL:
(load "my-project.lisp")
For prosjekt som bruker Quicklisp, ein bibliotekforvaltar, kan avhengigheiter lett bli administrert og lasta.
Lisp er spesielt kjent for sine applikasjonar innan kunstig intelligens, symbolsk berekning og akademia, men det finn også bruksområde i:
Lisp blir ofte samanlikna med:
Oversetting frå Lisp til andre språk blir ofte gjort ved hjelp av kilde-til-kilde oversettingsverktøy. For eksempel eksisterer følgjande verktøy:
Kvar av desse verktøya gir spesifikke kartleggingar som sikrar at kjernfunksjonalitetane til Lisp kan bli effektivt representert i målspråka. For meir komplekse oversettingar kan manuell refaktorering vere nødvendig, spesielt for kode som er tungt makrooptimalisert.