Tekst źródłowy strony Lisp

{{Język programowania infobox
 |nazwa          = Lisp
 |logo           = Lisp logo.svg
 |data           = [[1958]]
 |paradygmat     = [[Programowanie wieloparadygmatowe|wieloparadygmatowy]] ([[programowanie funkcyjne|funkcyjny]], [[programowanie obiektowe|obiektowy]], [[programowanie symboliczne|symboliczny]])
 |typowanie      = [[Typowanie dynamiczne|dynamiczne]]
 |implementacje  = 
 |pochodne       = [[Common Lisp]], [[Scheme]], [[Emacs Lisp]], [[AutoLISP]], [[Clojure]] i inne
 |wersja         = 
 |wersja testowa = 
 |twórca         = [[John McCarthy (informatyk)|John McCarthy]]
 |licencja       = 
 |platforma      = 
 |system         = 
 |wikibooks      = 
 |commons        = 
 |www            = 
}}
'''Lisp'''<ref>[https://sjp.pwn.pl/szukaj/lisp.html Odmiana:] [[Mianownik (przypadek)|M]]. ''Lisp'', [[dopełniacz (przypadek)|D]]. ''Lispu'', [[celownik (przypadek)|C]]. ''Lispowi'', [[Biernik|B]]. ''Lisp'', [[Narzędnik|N]]. ''Lispem'', [[Miejscownik|M]]. ''Lispie''.</ref> – rodzina [[język programowania|języków programowania]] z długą historią i charakterystyczną składnią. Zaprojektowany przez [[John McCarthy (informatyk)|Johna McCarthy’ego]] na [[Massachusetts Institute of Technology|MIT]] w 1958 roku. Pierwszym interpreterem języka Lisp była implementacja funkcji ''eval'' wykonana przez studenta McCarthy’ego – [[Steve Russell|Steve’a Russella]]. Lisp jest drugim z kolei pod względem wieku językiem programowania wysokiego poziomu pozostającym w użyciu (starszy jest tylko [[Fortran]]). Podobnie jak Fortran, Lisp ulegał na przestrzeni czasu licznym zmianom. Powstało również wiele jego dialektów. Dziś do najpopularniejszych należą trzy: [[Common Lisp]], [[Scheme]] i [[Clojure]].

Lisp powstał jako wygodna [[matematyka|matematyczna]] notacja dla [[program komputerowy|programów komputerowych]], oparta na [[rachunek lambda|rachunku lambda]] stworzonym przez [[Alonzo Church]]a. Szybko został najchętniej wybieranym językiem do badania i rozwoju [[sztuczna inteligencja|sztucznej inteligencji]]. Wywodzi się z niego wiele technik programistycznych, takich jak [[Drzewo (informatyka)|struktury drzewiaste]], [[odśmiecanie pamięci]], [[Typowanie dynamiczne|dynamiczne typowanie]] czy nowe koncepcje w [[programowanie obiektowe|programowaniu obiektowym]] ([[Common Lisp Object System]]).

Nazwa ''Lisp'' pochodzi od ''LISt Processing''. Podstawową strukturą danych w Lispie jest [[lista]]; [[kod źródłowy]] programów w Lispie składa się z list. Dzięki temu język jest [[Homoikoniczność|homoikoniczny]], tzn. programy w Lispie mogą manipulować kodem źródłowym jak zwykłą strukturą danych. Umożliwia to pisanie [[makro|makr]], pozwalających programiście tworzyć nową składnię lub nawet małe, zagnieżdżone w Lispie, języki [[Język dziedzinowy|DSL]].

Kod tworzony jako [[struktura danych]] sprawia, że Lisp ma charakterystyczną składnię. Cały kod źródłowy ma postać tzw. ''[[S-wyrażenie|S-wyrażeń]] (S-expressions)'', czyli list otoczonych nawiasami. Wywołanie funkcji, makra lub formy specjalnej ma postać listy, której pierwszym elementem jest nazwa funkcji, makra lub formy specjalnej lub wyrażenie, którego wynikiem jest funkcja, a następnymi elementami – argumenty. Na przykład funkcję o nazwie <code>f</code> z argumentami <code>a</code>, <code>b</code> i <code>c</code> wywołuje się za pomocą kodu {{Kod|(f a b c)|lisp}}, natomiast gdy {{Kod|(g a b)|lisp}} zwraca funkcje, można użyć {{Kod|((g a b) c d)|lisp}}.

== Historia ==
Lisp został wymyślony przez [[John McCarthy (informatyk)|Johna McCarthy’ego]] w 1958 podczas jego pobytu na [[Massachusetts Institute of Technology|MIT]]. W roku [[1960]] McCarthy opublikował swój projekt w ''[[Communications of the ACM]]'', w artykule pod tytułem ''„Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I”''<ref>[http://www.informatimago.com/develop/lisp/small-cl-pgms/aim-8/aim-8.html Transkrypcja AIM-8 Johna McCarthy’ego].</ref> (''Rekursywne funkcje wyrażeń symbolicznych i ich maszynowe obliczanie, część I''; części II nigdy nie opublikowano). Pokazał, że za pomocą kilku operatorów i notacji dla funkcji można zbudować język implementujący [[maszyna Turinga|maszynę Turinga]].

Pierwszą implementację Lispu opracował [[Steve Russell]] na komputerze [[IBM 704]] za pomocą [[Karta dziurkowana|kart dziurkowanych]]<ref>{{Cytuj |url=http://jmc.stanford.edu/articles/lisp/lisp.pdf |tytuł=History of Lisp |autor=John McCarthy |miejsce=Artificial Intelligence Laboratory Stanford University |data=1979-02-12 |data dostępu=2025-03-12 |s=4}}</ref>. Russell przeczytał artykuł McCarthy’ego i doszedł (ku zdziwieniu McCarthy’ego) do wniosku, że funkcję ''eval'' można zaimplementować jako [[Interpreter (program komputerowy)|interpreter]] Lispu<ref>[[Paul Graham]] w książce ''[[Hackers & Painters]]'' na stronie 185 przytacza wypowiedź McCarthy’ego: ''Steve Russell said, look, why don’t I program this ''eval''..., and I said to him, ho, ho, you’re confusing theory with practice, this ''eval'' is intended for reading, not for computing. But he went ahead and did it. That is, he compiled the ''eval'' in my paper into [[IBM 704]] machine code, fixing bug, and then advertised this as a Lisp interpreter, which it certainly was. So at that point Lisp had essentially the form that it has today...''</ref>.

Pierwszy kompletny kompilator Lispu stworzony w Lispie napisali w [[1962]] Tim Hart i Mike Levin na MIT<ref name="LEVIN">{{cytuj stronę |url = ftp://publications.ai.mit.edu/ai-publications/pdf/AIM-039.pdf |tytuł = AI Memo 39-The new compiler |autor = Tim Hart and Mike Levin |data dostępu = 2006-10-13}}</ref>. W kompilatorze tym wprowadzono model kompilacji przyrostowej (ang. ''incremental compilation''), dzięki czemu funkcje kompilowane i interpretowane nie były rozróżniane. Język użyty przez Harta i Levina był dużo bliższy nowoczesnemu stylowi Lispu niż wcześniejszy kod McCarthy’ego.

=== Wczesna historia ===
[[Information Processing Language]] był pierwszym językiem zaprojektowanym do tworzenia sztucznej inteligencji i już zawierał kilka pomysłów, które później zostały użyte w Lispie, jak na przykład przetwarzanie list czy [[rekurencja]].

Oryginalna notacja McCarthy’ego używała M-wyrażeń, które potem były przetwarzane na S-wyrażenia, na przykład M-wyrażenie <CODE><nowiki>car[cons[A,B]]</nowiki></CODE> jest równoznaczne z S-wyrażeniem <CODE>(car&nbsp;(cons&nbsp;A&nbsp;B))</CODE>. Gdy tylko Lisp został zaimplementowany, programiści szybko porzucili M-wyrażenia na rzecz S-wyrażeń. M-wyrażenia powróciły na chwilę w [[MLISP]]ie<ref name="SMITH">{{Cytuj stronę |url = https://www.saildart.org/AIM/084/pdf |tytuł = MLISP Users Manual |autor = David Canfield Smith |data dostępu = 2019-12-01}}</ref> autorstwa [[Horace Enea|Horace’a Enea]] i [[CGOL]]u autorstwa [[Vaughan Pratt|Vaughana Pratta]].

Dwa makra asemblera na maszynie [[IBM 704]] stały się podstawowymi operacjami do przetwarzania list: <code>car</code> ({{K|en|Contents of Address Register}}) i <code>[[cdr]]</code> ({{K|en|Contents of Decrement Register}})<ref>{{Cytuj stronę |url = http://www.iwriteiam.nl/HaCAR_CDR.html |tytuł = The origin of CAR and CDR in LISP |nazwisko = Faase |imię = Franciscus |język = en |data dostępu = 2013-08-20}}</ref>. Różne dialekty Lispu wciąż używają nazw <code>car</code> i <code>cdr</code> dla funkcji zwracających odpowiednio pierwszy element i resztę listy.

=== Genealogia i odmiany ===
Przez ponad 50 lat powstało wiele różnorakich dialektów Lispu – języka ze składnią złożoną z S-wyrażeń. Co więcej, część dialektów miało kilka implementacji – [[Common Lisp]], na przykład, posiada ich ponad tuzin.

Różnice między poszczególnymi dialektami mogą być znaczące – Common Lisp i [[Scheme]] używają na przykład różnych słów kluczowych do definiowania funkcji. Jednak wewnątrz dialektu takie różnice nie występują, każda zgodna implementacja obsługuje ten sam zestaw funkcji, poza którym często oferuje dodatkowe rozszerzenia i biblioteki.

==== Ważne historycznie dialekty ====
* LISP 1.5 [http://web.cse.ohio-state.edu/~rountev.1/6341/pdf/Manual.pdf] – Pierwsza szeroko rozprzestrzeniona wersja, stworzona przez McCarthy’ego i innych pracowników MIT. Zawierała trochę ulepszeń w stosunku do oryginalnego interpretera „LISP 1”, nie była jednak całkowicie nowa, jaka miała być wersja „LISP 2”, zatem zdecydowano się na taki właśnie numer wersji.
* [[Stanford LISP 1.6]] [http://www.softwarepreservation.net/projects/LISP/stanford/SAILON-28.6.pdf] – Wersja następna po LISP 1.5 stworzona w [[Stanford AI Lab]] i szeroko rozprzestrzeniona pod systemem {{Link-interwiki|TOPS-10|Q=Q1670222}} na maszynach [[PDP-10]]. Została zastąpiona przez Maclisp i InterLisp.
* [[Maclisp|MACLISP]] [https://web.archive.org/web/20080420150707/http://zane.brouhaha.com/~healyzh/doc/lisp.doc.txt] – stworzony dla „Projektu MAC” w MIT (bez związku z [[Macintosh|Apple Macintosh]] ani z McCarthym), bezpośredni spadkobierca LISP 1.5. Działał na PDP-10 pod [[Multics]]em. (MACLISP później został przemianowany na Maclisp, często bywa również nazywany MacLispem).
* [[Interlisp|InterLisp]] [http://www.softwarepreservation.org/projects/LISP/interlisp-d/3100186-Interlisp_Oct83.pdf] – stworzony w [[BBN Technologies]] na komputery PDP-10 działające z systemem [[TOPS-20|Tenex]], później zaadaptowany dla maszyn Lispu [[Xerox]]a. Mała wersja zwana „InterLISP 65” została wydana dla komputerów marki [[Atari (amerykańskie przedsiębiorstwo)|Atari]] bazujących na procesorze [[MOS Technology 6502|MOS 6502]]. Przez pewien czas Maclisp i InterLisp były w równie szerokim użyciu.
* {{Link-interwiki|Franz Lisp|Q=Q5492884}} – początkowo projekt [[Uniwersytet Kalifornijski w Berkeley|Berkeley]], później zaimplementowany przez [[Franz Inc]]. Nazwa jest żartobliwą deformacją imienia „[[Ferenc Liszt|Franz Liszt]]”. Nazwa „Franz Lisp” nie odnosi się do [[Allegro Common Lisp]], odmiany Common Lispu sprzedawanej przez Franz Inc. w ostatnim czasie.
* [[ZetaLisp]] – używany na [[maszyna Lispowa|maszynach Lispowych]], bezpośredni następca Maclispu.
* [[Emacs Lisp]] – używany jako język rozszerzeń edytora [[Emacs]].
* [[Common Lisp|Common Lisp (1984)]], opisany w ''Common Lisp: The Language'' – połączenie kilku różnych podejść (ZetaLisp, [[Spice Lisp]], [[NUL (LISP)|NIL]] i [[S-1 Lisp]]) do stworzenia następcy Maclispu z pewnymi wpływami ze Scheme. Ta wersja Common Lispu była dostępna na wiele platform i uznawana za standard do czasu pojawienia się specyfikacji ANSI Common Lisp (ANSI X3.226-1994).
* {{Link-interwiki|EuLisp|Q=Q5405195}} – próba stworzenia nowego, wydajnego i oczyszczonego z historycznego bagażu dialektu Lispu.
* {{Link-interwiki|ISLisp|Q=Q5974027}} – jw. Ustandaryzowany<ref>[http://islisp.info/specification.html Standardy ISLispu].</ref> jako [http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=22987 ISO/IEC 13816:1997] i później skorygowany w [http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=44338 ISO/IEC 13816:2007] – ''Information technology – Programming languages, their environments and system software interfaces – Programming language ISLISP''.
* [[Scheme|IEEE Scheme]] – standard IEEE, 1178-1990 (R1995).
* [[Common Lisp|ANSI Common Lisp]] – specyfikacja [[American National Standards Institute]] (ANSI) Common Lispu, stworzona przez podkomisję {{Link-interwiki|X3J13|Q=Q8041648}}, która rozpoczęła pracę[http://www.nhplace.com/kent/CL/x3j13-86-020.html] wychodząc od ''Common Lisp: The Language'' jako dokumentu bazowego i działała na zasadzie publicznego [[konsensus]]u co do zagadnień przenośności i kompatybilności implementacji Common Lispu. Pomimo iż formalnie jest to standard ANSI, implementacje, sprzedaż, wykorzystanie i wpływ ANSI Common Lispu było i jest widoczne na całym świecie.

=== Powiązania ze sztuczną inteligencją ===
Od swoich początków Lisp był blisko powiązany ze społecznością badającą i rozwijającą [[sztuczna inteligencja|sztuczną inteligencję]], szczególnie na [[PDP-10]]<ref>36-[[Bit|bitowy]] rozmiar słowa na [[PDP-6]]/[[PDP-10]] został wprowadzony ze względu na użyteczność trzymania dwóch 18-bitowych Lispowych wskaźników w jednym słowie. „The PDP-6 project started in early 1963, as a 24-bit machine. It grew to 36 bits for LISP, a design goal.” („Projekt PDP-6 został rozpoczęty w 1963 jako maszyna 24-bitowa. Urosła do 36 bitów dla LISPu, celu projektowego.”) [http://groups.google.com/group/alt.folklore.computers/browse_thread/thread/6e5602ce733d0ec/17597705ae289112].</ref>. Lisp został użyty w implementacji języka programowania [[Micro Planner]], który był podstawą znanego systemu SI [[SHRDLU]]. W [[Lata 70. XX wieku|latach 70.]], gdy badania nad AI rozwinęły się również po stronie komercyjnej, wydajność istniejących systemów Lispu stawała się coraz ważniejszym problemem.

Lisp był trudny do implementacji na zwykłych kompilatorach i sprzęcie dostępnym w 1970. [[Odśmiecanie pamięci|Garbage collection]], stworzone przez [[Daniel Edwards|Daniela Edwardsa]], wpłynęło na użyteczność Lispu na sprzęcie obliczeniowym ogólnego przeznaczenia, ale wydajność wciąż była problemem. Doprowadziło to do stworzenia [[maszyna lispowa|maszyn lispowych]]: dedykowanego sprzętu do uruchamiania środowisk i programów w Lispie. Postęp w dziedzinie sprzętu komputerowego, jak również w kompilatorach wkrótce sprawił, że maszyny lispowe stały się przestarzałe, co zaszkodziło rynkowi Lispu.

W latach [[lata 80. XX wieku|80.]] i [[lata 90. XX wieku|90.]] włożono duży wysiłek w zunifikowanie wielu dialektów Lispu (szczególnie dialektów [[InterLisp]], [[Maclisp]], [[ZetaLisp]], i [[Franz Lisp]]) w pojedynczy język. Nowy język, [[Common Lisp]] był istotnie kompatybilnym podzbiorem dialektów, które zastępował. W [[1994]], [[American National Standards Institute|ANSI]] opublikowało specyfikację Common Lispu, „ANSI X3.226-1994 Information Technology Programming Language Common Lisp”. W tamtym czasie światowy rynek Lispu był dużo mniejszy niż obecnie.

=== Od 2000 ===
Po spadku popularności w latach 90. wywołanym m.in. upowszechnieniem się C++ i silnym marketingiem Javy, jak również brakiem dobrych i [[Wolne oprogramowanie|wolnych]] implementacji Lispu, Lisp doświadcza wzrostu zainteresowania od roku [[2000]]{{fakt|data=2012-12}}. Większość aktywności skupia się wokół stworzenia [[Otwarte oprogramowanie|open source’owych]] implementacji Common Lispu i zawiera rozwój nowych przenośnych bibliotek i aplikacji. Zainteresowanie to można częściowo zmierzyć przez sprzedaż papierowej wersji książki ''[[Practical Common Lisp]]'' autorstwa [[Peter Seibel|Petera Seibela]], wstępu do CL dla nowych programistów Lispu, opublikowanej w [[2004]] roku<ref>{{Cytuj stronę |url = http://gigamonkeys.com/blog/2007/05/26/pcl-third-printing.html |tytuł = Informacja o trzecim wydaniu PCL |opublikowany = gigamonkeys.com |archiwum = https://web.archive.org/web/20090620083904/http://gigamonkeys.com/blog/2007/05/26/pcl-third-printing.html |zarchiwizowano = 2009-06-20}}</ref>. Była ona drugą co do popularności książką o programowaniu na [[Amazon.com|Amazon]]. Aktualnie dostępna jest za darmo w [[internet|internecie]]<ref>[http://gigamonkeys.com/book/ Practical Common Lisp].</ref>. Można również zauważyć zwiększoną frekwencję na związanych z Lispem konferencjach<ref>[http://www.regdeveloper.co.uk/2007/04/02/international_lisp_conference_2007/ Keeping Lisp alive and practical | Reg Developer].</ref> i aktywność na powiązanych [[grupa dyskusyjna|grupach]]<ref>[http://www.complang.tuwien.ac.at/anton/comp.lang-statistics/ Programming language popularity].</ref>.

Wielu nowych programistów Lispu zostało zainspirowanych przez wypowiedzi takich postaci jak [[Paul Graham]] czy [[Eric Raymond|Eric S. Raymond]] by spopularyzować język uznawany za przestarzały. Nowi programiści zwykle opisują język jako dający nowe spojrzenie na programowanie i twierdzą, że dzięki temu stali się dużo bardziej wydajni niż w innych językach<ref>{{cytuj stronę |url = http://wiki.alu.org/The_Road_To_Lisp_Survey |tytuł = The Road To Lisp Survey |archiwum = https://web.archive.org/web/20120106121645/http://wiki.alu.org/The_Road_To_Lisp_Survey |zarchiwizowano = 2012-01-06 |data dostępu = 2006-10-13}}</ref>. Wpływ na odzyskiwanie popularności przez Lisp mógł mieć również komentarz [[Peter Norvig|Petera Norviga]]<ref>[http://norvig.com/Lisp-retro.html A Retrospective on PAIP].</ref>, autora książek ''[[Paradigms of AI Programming: Case Studies in Common Lisp]]'' i ''[[Artificial Intelligence: A Modern Approach]]'' lub [[Phillip Greenspun]], który odniósł sukces biznesowy, używając Lispu.

== Dialekty ==
Dwoma '''głównymi dialektami''' Lispu ogólnego przeznaczenia aktualnie są [[Common Lisp]] i [[Scheme]]. Języki te reprezentują znacząco różne podejścia projektowe.

'''Common Lisp''', bazujący głównie na [[Maclisp]]ie, [[InterLisp]] i dialektach z maszyn lispowych, jest poszerzonym nadzbiorem wcześniejszych dialektów, z szeroką specyfikacją, obejmującą wiele wbudowanych typów danych i form syntaktycznych, jak również system obiektowy.

'''Scheme''' reprezentuje podejście minimalistyczne, ze znacznie mniejszym zbiorem standardowych funkcji, ale za to z określonymi cechami implementacyjnymi (jak na przykład optymalizacja [[Rekurencja ogonowa|rekursji ogonowej]] czy pełne [[Instrukcja kontynuacji|kontynuacje]]), które niekoniecznie mogą być dostępne w Common Lispie. CL zapożyczył również pewne cechy ze Scheme jak na przykład [[leksykalny zasięg]] czy leksykalne [[domknięcie (programowanie)|domknięcie]].

Poza tym, dialekty Lispu są używane jako [[język skryptowy|'''języki skryptowe''']] w aplikacjach, z czego najbardziej znanymi są:
* [[Emacs Lisp]] w [[Emacs]]ie,
* [[AutoLISP]] w [[AutoCAD]]zie,
* {{Link-interwiki|TinyScheme|Q=Q764898}} w [[GIMP|Gimpie]],
* {{Link-interwiki|Nyquist|Q=Q1788197}} w [[Audacity]].

'''Nowe dialekty''' Lispa to:
* Arc,
* Nu,
* Clojure.

== Wpływ na świat programowania ==
Lisp był pierwszym językiem, w którym kod źródłowy był również strukturą danych używaną przez język – w tym przypadku listą. Umożliwiło to wprowadzenie makr (których nie należy mylić z prostymi makrami podstawieniowymi znanymi na przykład z preprocesora C), których zadaniem jest tworzenie kodu źródłowego podczas interpretowania (lub kompilacji) programu – makra to zatem programy piszące programy. Pozwalają one na pisanie eleganckiego kodu na wyższym poziomie abstrakcji i zredukowanie jego ilości.

Konstrukcja ''if-then-else'', współcześnie uznawana za konieczny element każdego języka programowania, została wymyślona przez McCarthy’ego dla Lispu w bardziej ogólnej formie (jako konstrukcja cond). Pomysł został skopiowany i spopularyzowany przez [[ALGOL|Algola]]. Lisp wprowadził również koncepcję [[Typowanie dynamiczne|dynamicznego typowania]] i mechanizm [[Odśmiecanie pamięci|garbage collection]].

Lisp wpłynął na [[Alan Kay|Alana Kaya]], który prowadził badania nad [[Smalltalk]]iem, by następnie ulec wpływowi Smalltalka przez wprowadzenie cech [[programowanie obiektowe|programowania obiektowego]] (klasy, metody itd.) pod koniec lat 70.

Głównie ze względu na wymagania systemowe Lisp nie zyskał takiej popularności poza społecznością badającą [[sztuczna inteligencja|SI]] jak na przykład [[Fortran]] czy [[C (język programowania)|C]]. Nowsze języki, takie jak [[Java]] czy [[Ruby (język programowania)|Ruby]] oferują część jego cech, mimo tego nie jest możliwe spójne zaimplementowanie dla nich wszystkich cech Lispu. W ostatnich latach wiodące implementacje Lispu zaczęły dorównywać wydajnością kompilatorom popularnych języków<ref>[http://www.lispworks.com/products/myths_and_legends.html Common Lisp – Myths and Legends].</ref>, w tym przewyższając o rzędy wielkości wydajność popularnych języków skryptowych, głównie ze względu na przejmowanie cech Lispu (GC, dynamiczne typowanie, refleksja) przez względnie „popularne” języki.

Zobacz też „The evolution of Lisp”<ref name="STEELE">{{cytuj stronę |url = http://www.dreamsongs.com/Files/HOPL2-Uncut.pdf |tytuł = The evolution of Lisp |autor = Guy L Steele Jr., Richard P Gabriel |data dostępu = 2006-10-12}}</ref>, artykuł autorstwa [[Guy L. Steele Jr.|Guya Steele’a Jr.]] i [[Richard P. Gabriel|Richarda Gabriela]].

== Składnia i semantyka ==
: '''''Uwaga''': Przykłady w tym artykule są pisane w Common Lispie (aczkolwiek większość z nich jest również prawidłowa w Scheme).''

Lisp jest językiem, którego składnia składa się z wyrażeń. W przeciwieństwie do większości innych języków, nie ma w nim podziału na [[wyrażenie (informatyka)|wyrażenia]] i [[instrukcja (informatyka)|instrukcje]] – cały kod i dane są zapisane jako wyrażenia. Wynikiem ''ewaluacji'' (''wartościowania'') wyrażeń jest wartość (lub lista wartości), która może być użyta jako argument do innego wyrażenia.

McCarthy w artykule z [[1958]] roku wprowadził dwa modele składni – [[S-wyrażenie|S-wyrażenia]] ({{K|en|Symbolic Expressions}}, wyrażenia symboliczne, zwane również sexpami), które odzwierciedlały wewnętrzną reprezentację kodu i danych, jak również M-wyrażenia ({{K|en|Meta Expressions}}, meta wyrażenia), które wyrażały zewnętrzny kod. M-wyrażenia nigdy nie stały się zbyt popularne i wszystkie popularne Lispy korzystają z S-wyrażeń do określania zarówno kodu, jak i danych.

Sposób użycia nawiasów jest najlepiej widocznym na pierwszy rzut oka faktem pozwalający odróżnić Lisp od innych rodzin języków. Z tego powodu Lisp był często krytykowany, głównie przez programistów innych języków, niektórzy nadali Lispowi takie przydomki jak {{K|en|Lost In Stupid Parentheses}} (''Zagubiony w głupich nawiasach'') czy {{K|en|Lots of Irritating Superfluous Parentheses}} (''Wiele irytujących zbytecznych nawiasów'')<ref name="LEVIN2">{{cytuj stronę |url = http://www.catb.org/~esr/jargon/html/L/LISP.html |tytuł = The Jargon File – Lisp |data dostępu = 2006-10-13}}</ref>. Jednakże składnia oparta na S-wyrażeniach leży u podstaw możliwości Lispu; jest niezwykle regularna, co ułatwia jej przetwarzanie przez [[komputer]]. Lisp nie jest jednak ograniczony do notacji nawiasowej – możliwe jest takie poszerzenie go, by używał innych, alternatywnych notacji. [[XMLisp]] na przykład to rozszerzenie Common Lispu integrujące S-wyrażenia z [[XML]]-em.

Bazowanie na wyrażeniach daje językowi dużą elastyczność. Ponieważ [[funkcja|funkcje]] w Lispie są zapisywane jako listy, mogą być manipulowane jak zwykłe dane. Umożliwia to łatwe pisanie programów, które operują na innych programach ([[metaprogramowanie]]). Wiele dialektów wykorzystuje tę cechę przez użycie systemu makr, które pozwalają na niemal nieograniczone poszerzanie języka.

Lista w Lispie jest zapisywana jako elementy rozdzielone [[biały znak|białymi znakami]] i otoczone [[nawias]]ami. Na przykład <code>(1 2 foo)</code> to lista, której elementami są trzy atomy, wartości <code>1</code>, <code>2</code>, i <code>[[Zmienna metasyntaktyczna|foo]]</code>. Te wartości są domyślnie typowane (ich typy nie muszą być deklarowane): są to odpowiednio dwie liczby całkowite i specyficzny dla Lispu typ symboliczny.

Wyrażenia są zapisywane jako listy z wykorzystaniem [[notacja polska|notacji polskiej]]. Pierwszym elementem listy jest nazwa formy, czyli funkcji, makra lub specjalnego operatora. Pozostałe elementy listy są argumentami. Na przykład funkcja <code>list</code> zwraca listę zbudowaną ze swoich argumentów, więc ewaluacja wyrażenia
<syntaxhighlight lang="lisp">
 (list '1 '2 'foo)
</syntaxhighlight>
zwróci listę <code>(1 2 foo)</code>. Apostrof przed każdym argumentem to skrócona forma specjalnego operatora ''quote'' ([[język angielski|ang.]] ''cytuj''), który zapobiega ewaluacji argumentów (stosowanie go do liczb nie jest konieczne, ponieważ 1 jest ewaluowane do 1 itp.). Każde wyrażenie niepoprzedzone apostrofem jest rekursywnie wartościowane przed ewaluacją otaczającego wyrażenia. Na przykład
<syntaxhighlight lang="lisp">
 (list 1 2 (list 3 4))
</syntaxhighlight>
zostanie ewaluowane do <code>(1 2 (3 4))</code>. Zauważ, że trzecim argumentem jest lista; listy mogą być zagnieżdżane.

[[Operator arytmetyczny|Operatory arytmetyczne]] są traktowane podobnie, jako że same w sobie są również funkcjami. Wyrażenie
<syntaxhighlight lang="lisp">
 (+ 1 2 3 4)
</syntaxhighlight>
zwraca po ewaluacji 10. Odpowiednik w [[notacja infiksowa|notacji infiksowej]] wyglądałby <code>1 + 2 + 3 + 4</code>. Funkcje arytmetyczne mogą przyjmować dowolną ilość argumentów.

Specjalne operatory (zwane również specjalnymi formami) zapewniają Lispowi struktury kontrolne. Na przykład specjalny operator <code>if</code> pobiera trzy argumenty i ewaluuje drugi, jeżeli pierwszy argument jest różny od nil, w przeciwnym razie ewaluuje trzeci. Zatem poniższy kod
<syntaxhighlight lang="lisp">
 (if nil
   (list 1 2 "foo")
   (list 3 4 "bar"))
</syntaxhighlight>
zwraca <code>(3 4 "bar")</code>. Oczywiście konstrukcja byłaby bardziej użyteczna, gdyby podstawić jakieś nietrywialne wyrażenie w miejsce <code>nil</code>.

=== Wyrażenia lambda ===
Inny specjalny operator, <code>lambda</code>, służy do tworzenia anonimowych funkcji, argumentami są lista argumentów funkcji wynikowej i wyrażenie, na podstawie którego wartościowana jest funkcja (wartością zwracaną jest wartość ostatniego obliczonego wyrażenia). Wyrażenie
<syntaxhighlight lang="lisp">
 (lambda (arg) (+ arg 1))
</syntaxhighlight>
zwraca funkcję, która przy wywołaniu pobiera jeden argument, przypisuje go do <code>arg</code> i zwraca go zwiększonego o jeden. Wyrażenia lambda traktowane są tak samo jak nazwane funkcje. Wyrażenie
<syntaxhighlight lang="lisp">
 ((lambda (arg) (+ arg 1)) 5)
</syntaxhighlight>
zwraca więc <code>6</code>.

=== Atomy ===
W oryginalnym ''LISPie'' dostępne były dwa podstawowe [[typ danych|typy danych]]: atomy i listy. [[Lista]] była skończoną uporządkowaną sekwencją elementów, w której każdy element był albo atomem, albo listą, a atom był liczbą lub symbolem. Symbol był unikalnym nazwanym obiektem, zapisanym jako alfanumeryczny ciąg znaków w kodzie źródłowym i używany był albo jako nazwa zmiennej, albo jako obiekt danych. Na przykład lista <code>(FOO (BAR 1) 2)</code> zawiera trzy elementy: symbol FOO, listę <code>(BAR 1)</code> i liczbę 2.

Podstawową różnicą pomiędzy atomami i listami był fakt, iż atomy były niezmienne i unikalne. Dwa atomy, które pojawiły się w różnych miejscach w kodzie źródłowym, ale były zapisane w dokładnie ten sam sposób, reprezentowały ten sam obiekt, podczas gdy każda lista była oddzielnym obiektem, mogła być modyfikowana niezależnie od innych list i odróżniana od nich za pomocą funkcji porównujących.

Gdy w późniejszych dialektach Lispu wprowadzono więcej typów danych, a styl programowania się zmienił, pojęcie atomu straciło swoją ważność. Wiele dialektów wciąż utrzymywało predykat ''atom'' dla [[Kompatybilność wsteczna|wstecznej kompatybilności]], definiując go jako prawdę dla wszystkiego, co nie było komórką [[cons]] (np. listy lub częściowej listy).

=== Komórki cons i listy ===
[[Plik:Cons-cells.svg|thumb|300px|Diagram dla listy (42 69 613)]]
[[Lista]] w Lispie jest jednokierunkowa. Każda komórka nazywa się ''cons'' (w Scheme ''para'', ang. {{K|en|pair}}) i składa się z dwóch [[wskaźnik (typ danych)|wskaźników]], zwanych ''car'' i ''cdr''.

Spośród wielu struktur danych, jakie mogą być zbudowane za pomocą komórek cons, najbardziej podstawową jest tzw. ''prawidłowa lista''. Prawidłowa lista składa się albo ze specjalnego symbolu ''nil'', reprezentującego pustą listę, albo z komórki cons, w której pierwszy wskaźnik ma wskazywać na obiekt przechowywany w komórce, a drugi na następny element listy, lub na ''nil'', jeżeli jest to element ostatni.

Jeżeli rozważamy komórkę, która jest głową listy, wtedy jej car wskazuje na pierwszy element, a cdr na resztę listy. Z tego powodu funkcje <code>car</code> i <code>cdr</code> są również zwane <code>first</code>(pierwszy) and <code>rest</code>(reszta), gdy odnosimy się do komórek cons, które są częściami listy (w przeciwieństwie np. do drzewa).

Wynika z tego, że lista w Lispie nie jest podstawowym obiektem, jak na przykład [[instancja (programowanie)|instancja]] [[Kontener (programowanie)|kontener]] w [[C++]] czy [[Java|Javie]]. Lista jest zbiorem bardziej podstawowych obiektów, jakimi są komórki cons. Zmienna, która wskazuje na listę, wskazuje tak naprawdę na pierwszą komórkę listy. Przejście po liście można wykonać np. za pomocą kolejnych wywołań funkcji <code>cdr</code> na liście lub za pomocą którejś z [[funkcja wyższego rzędu|funkcji wyższego rzędu]].

Ponieważ komórki cons i listy są takie powszechne w systemach lispowych, uznaje się często niepoprawnie, że są jedynymi strukturami danych w Lispie. Tak naprawdę wszystkie (poza najprostszymi) dialekty Lispu mają inne struktury danych, np. wektory ([[Tablica (informatyka)|tablice]], ang. {{K|en|vector}}), [[tablica asocjacyjna|hash tablice]], [[Struktura (programowanie)|struktury]] itd.

==== S-wyrażenia jako reprezentacja list ====
S-wyrażenia reprezentują strukturę [[lista|list]]. Jest kilka sposobów, by opisać tę samą listę za pomocą S-wyrażenia. Komórka cons może być opisana za pomocą ''notacji kropkowanych par'' (ang. {{K|en|dotted-par notation}}) jako <code>(a . b)</code>, gdzie <code>a</code> jest wskazywane przez car, natomiast <code>b</code> przez cdr. Prawidłowa lista może być opisana za pomocą tej notacji jako <code>(a . (b . (c . (d . nil))))</code>, co jest zwykle skracane do <code>(a b c d)</code> za pomocą ''notacji listy'' (ang. {{K|en|list notation}}). Nieprawidłowa lista może być zapisana za pomocą kombinacji obydwu tych sposobów – S-wyrażenie <code>(a b c . d)</code> reprezentuje listę trzech komórek cons, z czego w ostatniej cdr wskazuje na <code>d</code> (ta sama lista zapisana za pomocą pełnej notacji wyglądałaby następująco: <code>(a . (b . (c . d)))</code>).

==== Funkcje przetwarzające listy ====
Lisp zapewnia wiele wbudowanych funkcji służących do manipulowania listami. Listy mogą być tworzone bezpośrednio za pomocą funkcji <code>list</code>, która pobiera dowolną liczbę argumentów i zwraca listę zawierającą te argumenty:
<syntaxhighlight lang="lisp">
 (list 1 2 'a 3)
 ;zwraca (1 2 a 3)
</syntaxhighlight>
<syntaxhighlight lang="lisp">
 (list 1 '(2 3) 4)
 ;zwraca (1 (2 3) 4)
</syntaxhighlight>
Ze względu na fakt, iż listy są tworzone z komórek cons, funkcja <code>cons</code> może być użyta do dodania elementu na początek listy. Zauważ, że ta funkcja jest asymetryczna ze względu na sposób, w jaki obsługuje listy jako argumenty. Przyczyną tego jest wewnętrzna budowa list.
<syntaxhighlight lang="lisp">
 (cons 1 '(2 3))
 ;zwraca (1 2 3)
</syntaxhighlight>
<syntaxhighlight lang="lisp">
 (cons '(1 2) '(3 4))
 ;zwraca ((1 2) 3 4)
</syntaxhighlight>
Funkcja <code>[[append]]</code> łączy dwie lub więcej list w jedną. Ponieważ listy w Lispie są listami łączonymi jednostronnie, połączenie dwóch list ma [[Asymptotyczne tempo wzrostu|złożoność]] <math>O(n).</math>
<syntaxhighlight lang="lisp">
 (append '(1 2) '(3 4))
 ;zwraca (1 2 3 4)
</syntaxhighlight>
<syntaxhighlight lang="lisp">
 (append '(1 2 3) '() '(a) '(5 6))
 ;zwraca (1 2 3 a 5 6)
</syntaxhighlight>

==== Dzielone struktury ====
W Lispie listy, ze względu na jednostronne łączenie, mogą dzielić strukturę z innymi. To znaczy, że dwie listy mogą mieć ten sam ogon lub tę samą końcówkę. Na przykład po wykonaniu następującego kodu w [[Common Lisp]]ie:
<syntaxhighlight lang="lisp">
(setf foo (list 'a 'b 'c))
(setf bar (cons 'x (cdr foo)))
</syntaxhighlight>
listy <code>foo</code> i <code>bar</code> to odpowiednio <code>(a b c)</code> i <code>(x b c)</code>. Jednakże ogon <code>(b c)</code> w obu listach to ta sama struktura. Nie jest to kopia, komórki wskazujące na <code>b</code> i <code>c</code> znajdują się w tym samym miejscu w pamięci dla obu list.

Dzielenie struktur zamiast kopiowania może owocować dużym wzrostem wydajności. Ta technika jednak może oddziaływać w niepożądany sposób z funkcjami, które modyfikują listy przekazane do nich jako argument. Modyfikacja jednej listy, jak na przykład zamiana symbolu <code>c</code> na <code>goose</code>, zaowocuje modyfikacją obydwu:
<syntaxhighlight lang="lisp">
 (setf (third foo) 'goose)
</syntaxhighlight>
Ten kod zmienia <code>foo</code> na <code>(a b goose)</code>, przy okazji jednak zmieniając <code>bar</code> na <code>(x b goose)</code>, co może być niepożądane. Takie zachowanie może być przyczyną wielu błędów, a funkcje, które modyfikują przekazywane argumenty, są z tego powodu nazywane ''destrukcyjnymi''.

Zwolennicy [[programowanie funkcyjne|programowania funkcyjnego]] unikają funkcji destrukcyjnych. W dialekcie Scheme, który zaleca styl funkcyjny, nazwy funkcji destrukcyjnych są oznaczone ostrzegawczym wykrzyknikiem lub, jak to jest popularnie nazywane, znakiem „bang” – na przykład funkcja <code>set-car!</code> (czytaj ''set car bang''), która zamienia car komórki cons. W Common Lispie funkcje destrukcyjne są powszechne; odpowiednikiem <code>set-car!</code> jest funkcja <code>rplaca</code> (skrót od „replace car”). Niemniej jednak ta funkcja jest dość rzadko używana, ponieważ Common Lisp zawiera specjalne udogodnienie, <code>setf</code>, ułatwiające definiowanie i używanie funkcji destrukcyjnych. Częstym stylem programowania w CL jest pisanie kodu funkcyjnego (bez wywołań destrukcyjnych) podczas pisania wersji początkowej, by następnie dodać funkcje destrukcyjne jako optymalizację tam, gdzie to bezpieczne.

=== Ewaluowanie form i cytowanie ===
Lisp ewaluuje wyrażenia wprowadzane przez użytkownika. Symbole i listy zwracają zwykle jakieś prostsze wyrażenia – na przykład symbol zwraca wartość zmiennej, którą nazywa; <code>(+ 2 3)</code> zwraca <code>5</code>. Większość innych form zwraca jednak same siebie – jeżeli wprowadzisz <code>5</code> do Lispu, zwróci <code>5</code>.

Każde wyrażenie może zostać zacytowane, by zapobiec ewaluacji (jest to konieczne przy wprowadzaniu symboli i list). Tę rolę pełni specjalny operator <code>quote</code>, lub jego skrót <code>'</code> (pojedynczy znak [[apostrof]]u). Na przykład zwykle jeżeli wprowadzisz symbol <code>foo</code>, dostaniesz z powrotem wartość odpowiadającej zmiennej (lub błąd, jeżeli takowa zmienna nie istnieje). Jeżeli jednak chcesz odwoływać się nie do zmiennej, a do samego symbolu, musisz użyć <code>(quote foo)</code> lub, co znacznie popularniejsze, <code>'foo</code>.

Zarówno Common Lisp, jak i Scheme obsługują również operator ''[[Grawis|backquote]]'' (zwykle zwany ''quasiquote'' przez użytkowników Scheme) wprowadzany jako znak <code>'</code>. Jedyną różnicą ze zwykłym quote jest fakt, iż backquote pozwala na ewaluację i wstawienie wyniku wyrażenia do cytowanej listy za pomocą operatorów ''comma'' i ''comma-at''. Jeżeli zmienna <code>snue</code> ma wartość <code>(bar baz)</code>, to <code>'(foo ,snue)</code> jest ewaluowane do <code>(foo (bar baz))</code>, podczas gdy <code>'(foo ,@snue)</code> ewaluuje się do <code>(foo bar baz)</code>. Backquote jest najczęściej używany przy definiowaniu makr.

Formy ewaluujące się do samych siebie i formy cytowane są odpowiednikiem [[literał]]ów, znanych z innych języków. Możliwa jest jednak modyfikacja literałów wewnątrz kodu źródłowego. Na przykład jeżeli funkcja zwraca formę cytowaną, a kod wywołujący funkcje modyfikuje ją, wpłynie to na wynik zwracany przez kolejny wywołania danej funkcji.

<syntaxhighlight lang=lisp>
(defun powinna-byc-stala
   '(jeden dwa trzy))

(let ((zmienna (powinna-byc-stala)))
   (setf (third zmienna) 'cos))   ; źle!

(powinna-byc-stala)   ; zwraca (jeden dwa cos)
</syntaxhighlight>

Modyfikacja formy cytowanej w taki sposób jest ogólnie uznawana za przykład złego stylu programowania, a część implementacji definiuje ją jako błędną (czego wynikiem jest [[zachowanie nieokreślone]] w plikach kompilowanych, ponieważ kompilator może połączyć podobne stałe, umieścić je w obszarze pamięci tylko do odczytu itp.). Kiedy takie zachowanie jest zamierzone, odpowiednim sposobem jest użycie [[Domknięcie (programowanie)|domknięcia]].

=== Zasięg i [[Domknięcie (programowanie)|domknięcia]] ===
Nowe dialekty Lispu można podzielić na podstawie zasad zasięgu (wiązania zmiennych) – część z nich używa [[zasięg dynamiczny|zasięgów dynamicznych]], część [[zasięg statyczny|statycznych]] (leksykalnych). Scheme i Common Lisp używają domyślnie zasięgu leksykalnego, podczas gdy bardziej prymitywne dialekty używane jako języki zagnieżdżone w [[Emacs]]ie i [[AutoCAD]]zie używają zasięgów dynamicznych.

Przykład zasięgu dynamicznego w Emacs-Lisp
<syntaxhighlight lang=lisp>
(defun foo ()
  (* x x))

(defun bar ()
  (let ((x 10))
    (message (int-to-string (foo)))))

(bar)
</syntaxhighlight>

Chociaż zmienna '''x''' nie została zdefiniowana wewnątrz funkcji '''foo''', to wywołanie funkcji '''bar''' wyświetli liczbę 100. W przypadku zasięgu dynamicznego zmienne zachowują się tak jakby były globalne, ale czas ich istnienia jest ograniczony do bloku, w którym zostały zdefiniowane.

Ten sam kod przepisany w Common Lispie zwróci błąd informujący, że zmienna '''x''' wewnątrz funkcji '''foo''' jest niezdefiniowana.

<syntaxhighlight lang=lisp>
(defun foo ()
  (* x x))

(defun bar ()
  (let ((x 10))
    (print (foo))))

(bar)
</syntaxhighlight>

W przypadku funkcji, która została utworzona z zasięgiem dynamicznym, jeśli dana zmienna nie znajduje się wewnątrz funkcji, to jest ona poszukiwana od miejsca, w którym została wywołana w górę aż do zasięgu globalnego. W przypadku zasięgu leksykalnego zmienne są poszukiwane od miejsca, w którym ta funkcja została zdefiniowana. Drugi przypadek jest najczęściej stosowany w innych językach programowania.

'''Przykład domknięcia leksykalnego w dialekcie [[Scheme]]'''
<syntaxhighlight lang=scheme>
(define (make-counter x)
  (let ((count x))
    (define (counter)
      (set! count (+ count 1))
      count)
    counter))

(define count-form-10 (make-counter 10))

(display (count-form-10))
(newline)
(display (count-form-10))
(newline)
;Powyższy kod wyświetli 11 i 12.
</syntaxhighlight>

Funkcja '''make-counter''' tworzy nową funkcję '''counter'''. Chociaż zakres zmiennej '''count''' po zakończeniu wywołania funkcji '''make-counter''' powinien się zakończyć, to funkcja '''counter''' zwrócona przez funkcję '''make-counter''' ma nadal do niej dostęp, tzn. zmienna '''count''' jest domknięta wewnątrz funkcji '''counter'''.

=== Kod źródłowy jako lista ===
Główną różnicą między Lispem a innymi językami jest fakt, iż w Lispie [[kod źródłowy]] programu nie jest po prostu tekstem. S-wyrażenia, jak opisano wyżej, są drukowaną reprezentacją kodu, jednak gdy tylko zostają wprowadzone do systemu Lispu, są tłumaczone przez parser (funkcję <code>read</code>) do postaci listy i struktur drzewiastych w pamięci.

Makra Lispu operują na tych strukturach. Ponieważ kod w Lispie ma taką samą strukturę jak lista, makra mogą być tworzone za pomocą wszystkich funkcji przetwarzających listy dostępnych w języku. W skrócie, wszystko, co Lisp może zrobić ze strukturą danych, makra Lispu mogą zrobić z kodem. W przeciwieństwie do tego, wynik parsowania w większości języków jest wyłącznie do użytku przez implementację i niedostępny dla programisty. Makra w [[C (język programowania)|C]] na przykład działają na poziomie [[preprocesor]]a, zanim parser jest uruchamiany, i nie mogą restrukturyzować kodu programu tak jak makra Lispu.

W prostych implementacjach Lispu, ta struktura jest bezpośrednio interpretowana podczas uruchamiania programu; funkcja to dosłownie pewna lista, przez którą interpreter przechodzi podczas uruchamiania danej funkcji. Większość systemów Lispu do poważnych zastosowań zawiera jednak również [[kompilator]]. Kompilator tłumaczy listę do [[Język maszynowy|kodu maszynowego]] lub [[Kod bajtowy|kodu bajtowego]] przed wywołaniem.

=== Ewaluacja i REPL ===
W wielu dialektach Lispu dostępna jest interaktywna [[wiersz poleceń|linia poleceń]], która może zostać włączona do [[zintegrowane środowisko programistyczne|IDE]]. Użytkownik wpisuje [[wyrażenie (informatyka)|wyrażenia]] do linii poleceń, lub sprawia, by IDE wysyłało je do systemu Lispu. Lisp czyta (ang. {{K|en|read}}) wprowadzone wyrażenie, ewaluuje je (ang. {{K|en|evaluate}}) i wypisuje (ang. {{K|en|print}}) wynik. Z tego powodu linia poleceń Lispu jest nazywana „{{J|en|read-eval-print loop}}” (''pętla wczytaj-ewaluuj-wypisz''), lub w skrócie REPL.

Oto podstawowy opis działania REPL. Jest on uproszczony, nie bierze pod uwagę wielu elementów prawdziwego Lispu, jak na przykład cytowanie czy makra.

Funkcja ''read'' akceptuje ciąg znaków zawierający S-wyrażenie jako argument i zwraca odpowiadającą mu listę. Na przykład jeżeli użytkownik wprowadzi ciąg znaków „<code>(+ 1 2)</code>”, <code>read</code> przetłumaczy go na listę z trzema elementami: symbolem <code>+</code>, liczbą 1 i liczbą 2. Ta lista jest również prawidłowym kawałkiem kodu w Lispie, to znaczy może być ewaluowana. Jest to możliwe, ponieważ car listy wskazuje na funkcję <code>+</code> – operator dodawania, a dokładnie symbol plus, który wskazuje na funkcje, która dodaje liczby. Jest to ważne rozróżnienie, gdyż użytkownik może przypisywać takie same funkcje do prawie dowolnych ciągów symboli.

Funkcja <code>eval</code> ewaluuje listę, zwracając inną listę jako wynik. Ewaluacja nie jest konieczne interpretacją – część systemów Lispu kompiluje w locie każde wyrażenie do kodu maszynowego. Opisywanie ewaluacji jako interpretacji jednak jest dużo prostsze: by zewaluować listę, w której car wskazuje na funkcję, <code>eval</code> najpierw [[rekurencja|rekurencyjnie]] ewaluuje każdy argument w cdr, by następnie z wynikami tych ewaluacji wywołać daną funkcję. W danym przykładzie funkcją jest dodawanie, wywoływane z listą argumentów <code>(1 2)</code> zwraca wynik <code>3</code>. Jest to wynik ewaluacji.

Zadaniem funkcji <code>print</code> jest reprezentacja wartości wynikowej w sposób czytelny dla użytkownika. Dla prostych wartości takich jak <code>3</code>, to zadanie jest trywialne. Dla list <code>print</code> musi przetworzyć całą strukturę i wypisać ją jako S-wyrażenie.

By zaimplementować lispowy REPL, wystarczy zaimplementować te trzy funkcje i funkcję nieskończonej [[Pętla (informatyka)|pętli]] (implementacja funkcji <code>eval</code> może być skomplikowana, gdyż wymaga implementacji wszystkich specjalnych operatorów takich jak <code>if</code>). Gdy to zostanie wykonane, podstawowy REPL może być wprowadzony za pomocą tylko jednej linii kodu: {{Kod|(loop (print (eval (read))))|lisp}}.

Kod w Lispie jest [[wartościowanie zachłanne|wartościowany zachłannie]]. W [[Common Lisp]]ie argumenty są wartościowane w kolejności od lewej do prawej, podczas gdy specyfikacja Scheme tego nie definiuje, pozostawiając kompilatorom możliwość optymalizacji.

=== Struktury kontrolne ===
Lisp początkowo miał niewiele struktur kontrolnych, wiele zostało dodanych w czasie, gdy język ewoluował. Pierwotny operator warunkowy Lispu, <code>cond</code>, jest prekursorem późniejszej konstrukcji <code>if-then-else</code>.

Programiści [[Scheme]] zwykle wyrażają pętle za pomocą [[Rekurencja ogonowa|rekursji ogonowej]]. Powszechność Scheme w nauczaniu akademickim sprawiła, że wielu uczniów zaczęło myśleć, że rekursja jest jedyną (lub najpopularniejszą) metodą opisywania iteracji w Lispie, co jest nieprawdą. Wszystkie często spotykane dialekty Lispu mają imperatywne konstrukcje pętli, począwszy od znanej ze Scheme pętli <code>do</code> po złożoną konstrukcję <code>loop</code> z Common Lispu. Przyczyną tak wielkiej popularności rekursji ogonowej w Scheme jest wsparcie tego w specyfikacji – daje ona określone zasady, jak traktować wywołania ogonowe, dzięki czemu programiści mogą mieć pewność, że zostaną one zamienione na pętlę. W przeciwieństwie do tego [[Common Lisp|ANSI Common Lisp]] nie daje<ref>[http://www.lispworks.com/documentation/HyperSpec/Body/03_bbc.htm 3.2.2.3 Semantic Constraints] in [http://www.lispworks.com/documentation/HyperSpec/Front/index.htm ''Common Lisp HyperSpec''].</ref> określonych wskazówek odnośnie do rekursji ogonowej, co sprawia, że część implementacji traktuje wywołania ogonowe jak zwykłe. W związku z tym fakt, iż używanie rekursji ogonowej jako zamiennika pętli jest w Common Lispie niezalecane<ref>4.3. Control Abstraction (Recursion vs. Iteration) w [http://www.cs.umd.edu/~nau/cmsc421/norvig-lisp-style.pdf Tutorial on Good Lisp Programming Style] autorstwa [[Kent Pitman|Kenta Pitmana]] i [[Peter Norvig|Petera Norvig]], sierpień 1993.</ref> nie jest jedynie kwestią stylistyczną, ale również wpływ na to ma wydajność (ponieważ nawet oczywiste wywołanie ogonowe niekoniecznie może być zamienione na pojedynczy skok) i poprawność (ponieważ wiele wywołań ogonowych niezamienionych na skok może grozić [[przepełnienie stosu|przepełnieniem stosu]]).

Część wyrażeń w Lispie to ''specjalne operatory'', odpowiadające znanym z innych języków słowom kluczowym. Wyrażenia te wyglądają z zewnątrz tak samo, jak wywołania funkcji, różnią się jednak tym, że argumenty nie zawsze są wartościowane – lub, w przypadku pętli, mogą być wartościowane więcej niż raz.

W przeciwieństwie do większości innych języków, Lisp pozwala programiście na implementację własnych struktur kontrolnych wewnątrz samego języka. Część wbudowanych struktur kontrolnych jest zaimplementowanych jako makra i mogą być (za pomocą funkcji <code>macroexpand</code> lub <code>macroexpand-1</code>) rozwinięte przez programistę, który chce się dowiedzieć, jak działają.

Zarówno Common Lisp, jak i Scheme zawierają operatory służące do nielokalnej kontroli przepływu. Różnice między tymi operatorami to najgłębsze różnice między tymi dwoma dialektami. Scheme obsługuje ''wielowejściowe kontynuacje'' za pomocą operatora <code>call/cc</code>, który pozwala na zapisanie (i późniejsze przywrócenie) określonego miejsca w wykonywaniu. Common Lisp nie obsługuje takich kontynuacji, ale zapewnia kilka sposobów na obsługę kontynuacji wyjścia.

Często ten sam algorytm może być wyrażony w Lispie zarówno funkcyjnie, jak i imperatywnie. Jak zaznaczono powyżej, Scheme raczej rekomenduje styl funkcyjny, używając rekursji ogonowej i kontynuacji do kontroli przepływu. Imperatywny styl programowania jest jednak wciąż możliwy. Styl preferowany przez wielu programistów Common Lispu może wydawać się bardziej znajomy programistom przyzwyczajonym do strukturalnych języków takich jak C, podczas gdy styl Scheme bardziej przypomina języki czysto funkcyjne takie jak np. [[Haskell]].

Ze względu na wczesne specjalizowanie w przetwarzaniu list, Lisp posiada szeroką gamę [[funkcja wyższego rzędu|funkcji wyższego rzędu]] służących do przechodzenia po sekwencjach. Często tam, gdzie w innych językach potrzebna byłaby bezpośrednia pętla (jak <code>for</code> w C), w Lispie to samo zadanie może być wykonane przy pomocy jednej z funkcji wyższego rzędu, podobnie jest w innych funkcyjnych językach programowania.

Dobrym przykładem jest funkcja w Scheme zwana <code>map</code>, a w Common Lispie <code>mapcar</code>. Po podaniu funkcji i jednej lub kilku list, <code>mapcar</code> stosuje tę funkcję kolejno do elementów list, zbierając wyniki do nowej listy.
<syntaxhighlight lang="lisp">
 (mapcar #'+ '(1 2 3 4 5) '(10 20 30 40 50))
</syntaxhighlight>
W tym przypadku funkcja <code>+</code> stosowana jest do odpowiadających sobie par argumentów, zwracając w wyniku listę <code>(11 22 33 44 55)</code>.

=== Przykłady ===
Oto kilka przykładów kodu w Common Lispie.

Program „[[Hello world]]”:
<syntaxhighlight lang="lisp">
  (print "Hello world")
</syntaxhighlight>
Jak czytelnik mógł wywnioskować z powyższych opisów, składnia Lispu naturalnie skłania się ku rekursji. Matematyczne problemy, takie jak generacja rekursywnie zdefiniowanych zbiorów, są proste do zapisania w tej notacji.

Obliczenie [[silnia|silni]] danej liczby:
<syntaxhighlight lang="lisp">
 (defun factorial (n)
   (if (<= n 1)
     1
     (* n (factorial (- n 1)))))
</syntaxhighlight>
Alternatywna implementacja, zwykle szybsza, jeżeli dana implementacja Lispu stosuje optymalizację [[Rekurencja ogonowa|rekursji ogonowej]]:
<syntaxhighlight lang="lisp">
 (defun factorial (n &optional (acc 1))
   (if (<= n 1)
     acc
     (factorial (- n 1) (* acc n))))
</syntaxhighlight>
Jeszcze inna implementacja, zamiast rekurencji wykorzystująca makro <code>loop</code> z Common Lispu:
<syntaxhighlight lang="lisp">
 (defun factorial (n)
   (loop for i from 1 to n
     for fac = 1 then (* fac i)
     finally (return fac)))
</syntaxhighlight>

Funkcja odwracająca listę (wbudowana funkcja <code>reverse</code> wykonuje to samo zadanie, istnieje też destrukcyjny odpowiednik <code>nreverse</code>):
<syntaxhighlight lang="lisp">
 (defun -reverse (l &optional acc)
   (if (atom l)
     acc
     (-reverse (cdr l) (cons (car l) acc))))
</syntaxhighlight>

== Funkcje wyższego rzędu ==
Funkcje wyższego rzędu są jednym z elementów [[Programowanie funkcyjne|programowania funkcyjnego]]. W Lispie funkcje można przypisywać do zmiennych przekazywać jako parametry do innych funkcji, mogą być także zwracane jako wartości przez funkcję. Funkcja, która operuje na innych funkcjach, jest nazywana funkcją wyższego rzędu (ang. {{K|en|Higher Order Procedure}}).

'''Przykład funkcji w Common Lispie'''

<syntaxhighlight lang="lisp">
(print (reduce #'+ '(1 2 3 4 5 6 7 8)))
> 36
</syntaxhighlight>

W powyższym przykładzie funkcja '''reduce''' jest funkcją wbudowaną, która skraca listę do pojedynczej wartości, wywołując kolejno funkcję przekazywaną jako parametr dla wyniku poprzedniego wywołania funkcji i kolejnego elementu listy. W dialekcie Common Lisp, przekazując funkcję jako parametr, należy poprzedzić je dodatkowo znakiem cytowania, ponieważ w tym dialekcie istnieją dwie przestrzenie nazw dla zmiennych i funkcji. W przypadku tworzenia funkcji wyższego rzędu w dialekcie [[Scheme]] nie stosuje się cytowania.

<syntaxhighlight lang="lisp">
(defun fun (x)
  (lambda (a b)
    (setq x (1+ x))
    (+ a b x)))

(print (reduce (fun 0) '(1 2 3 4 5 6 7 8)))
</syntaxhighlight>
W powyższym przykładzie zastosowano dodatkowo funkcję wyższego rzędu '''fun''', która zwraca funkcję sumującą, która dodatkowo dodaje indeks elementu w liście. Parametr '''x''' jest domknięty wewnątrz funkcji anonimowej. W miejsce wywołania funkcji '''fun''' można wstawić wyrażenie lambda.

<syntaxhighlight lang="lisp">
(let ((x 0))
  (print (reduce (lambda (a b)
                   (setq x (1+ x))
                   (+ a b x))
         '(1 2 3 4 5 6 7 8))))
</syntaxhighlight>

W Common Lispie, aby wywołać funkcję przechowywaną w zmiennej lub parametrze, trzeba ją wywołać za pomocą funkcji '''funcall''' lub '''apply'''
<syntaxhighlight lang="lisp">
(defun make-fun (x)
  (lambda (a b)
    (setq x (1+ x))
    (+ a b x)))

(defvar fun (make-fun 20))

(print (funcall fun 2 3))
;lub
(print (apply fun '(2 3)))
</syntaxhighlight>
Jeżeli funkcja jest wewnątrz zmiennej, nie trzeba jej cytować.

W przypadku dialektu [[Scheme]] czy [[Clojure]] nie stosuje się cytowania funkcji, ponieważ oba języki posiadają jedną przestrzeń nazw dla funkcji i zmiennych, nie występuje w nich także funkcja '''funcall''', ponieważ funkcje wewnątrz zmiennych wywołuje się tak samo jak zwykłe funkcje.

'''Przykład funkcji w języku [[Clojure]]'''
<syntaxhighlight lang="lisp">
(defn sum [& list]
  (reduce + list))
</syntaxhighlight>

Inne powszechnie stosowane funkcje wyższego rzędu to funkcja mapująca (wywołująca funkcję dla każdego elementu listy i zwracająca nową listę) i funkcja filtrująca (która zwraca listę pomniejszoną o te elementy, dla których funkcja przekazana jako parametr zwraca wartość fałszu).

== Makra ==
Makra są najpotężniejszym elementem języka Lisp i są dla niego unikalne. Dzięki makrom można dodawać nowe elementy do języka. Makro lispowe w odróżnieniu np. od makr występujących w pre-procesorze [[C (język programowania)|języka C]] operuje na kodzie języka Lisp tak jak na danych. W przypadku funkcji wyrażenia, które są przekazywane jako parametry, są obliczane przed wywołaniem samej funkcji, a wynik tego wyrażenia jest przekazywany jako parametr, w przypadku makra wyrażenia nie są obliczane, ale przekazane w całości jako dane w parametrze, które są przez makro przetwarzane, następnie makro powinno zwrócić kod lispowy także w postaci listy, która zostanie obliczona.

<syntaxhighlight lang="lisp">
(defmacro def (name val)
  (list 'setq name val))
</syntaxhighlight>
Przykład makra do tworzenia zmiennych. Aby ułatwić pisanie makr, dodano specjalny zapis cytowania z odwrotnym apostrofem.
Odwrotne cytowanie działa tak jak normalne z wyjątkiem specjalnych znaków przecinka i przecinka i małpy, które obliczają wyrażenie (wyłączają cytowanie), przecinek małpa dodatkowo usuwa otaczające nawiasy (stosuje się to np. wtedy gdy przekazujemy ciąg wyrażeń do makra w parametrze typu &body). Wszystkie trzy znaki są to skróty interpretera Lispu, które są zamieniane na funkcje.

<syntaxhighlight lang="lisp">
(defmacro while (test &body body)
  '(do ()
       ((not ,test))
       ,@body))
</syntaxhighlight>
Powyższe makro tworzy nowe wyrażenie implementujące pętlę while. Do testowania makr służą dwie funkcje '''macroexpand''', która rozwija makro [[Rekurencja|rekurencyjnie]] aż do napotkania podstawowych wyrażeń i funkcji oraz '''macroepxand-1''', która rozwija makro o jeden poziom.
Przykład użycia funkcji w interpreterze [[CLISP]]
<syntaxhighlight lang="lisp">
(print (macroexpand '(while (< x 10)
                        (print x)
                        (setq x (1+ x)))))
(BLOCK NIL
 (LET NIL
  (TAGBODY #:LOOP-11439 (IF (NOT (< X 10)) (GO #:END-11440)) (PRINT X)
   (SETQ X (1+ X)) (PSETQ) (GO #:LOOP-11439) #:END-11440
   (RETURN-FROM NIL (PROGN)))))
</syntaxhighlight>

Wywołanie '''macroexpand''' rozwinęło oprócz naszego makra także wbudowane makro '''do'''.

<syntaxhighlight lang="lisp">
(print (macroexpand-1 '(while (< x 10)
                          (print x)
                          (setq x (1+ x)))))

(DO NIL ((NOT (< X 10))) (PRINT X) (SETQ X (1+ X)))
</syntaxhighlight>
Dopiero wywołanie '''macroexpand-1''' pokazało nasze makro po rozwinięciu.

== Systemy obiektowe ==
Wiele różnych systemów i modeli obiektowości zostało zbudowanych na podstawie Lispu, między innymi:
* '''ObjectLisp'''<ref>Str. 17 z Bobrow 1986.</ref>, lub '''Object Lisp''', używany przez [[Lisp Machines Incorporated]]
* '''LOOPS''' (Lisp Object-Oriented Programming System) i późniejszy '''CommonLOOPS'''
* '''Flavors''', stworzony na [[Massachusetts Institute of Technology|MIT]] i jego spadkobierca '''New Flavors''', używany przez [[Symbolics]]
* '''[[Common Lisp Object System]]''', '''CLOS''', następca New Flavors i CommonLOOPS
* '''[[Lush]]''' – zorientowany obiektowo język programowania bazujący na Lispie
* '''SageCLOS''' zorientowany obiektowo interfejs do [[AutoLISP]]u stworzony przez Ralpha Gimeneza

CLOS obsługuje [[dziedziczenie (programowanie)|wielokrotne dziedziczenie]], [[multimetoda|multimetody]] i system „kombinacji metod”. W gruncie rzeczy [[Common Lisp]] zawierający CLOS był pierwszym oficjalnie ustandaryzowanym językiem zorientowanym obiektowo.

== Lisp w kulturze ==
=== Cytaty ===
{{Cytat
|treść=''SQL, Lisp i Haskell to jedyne języki programowania, jakie znam, w których spędza się więcej czasu na myślenie niż na pisanie.''
|autor={{Link-interwiki|Philip Greenspun|Q=Q7183648}}, [[marzec 2007]]
|źródło=[https://philip.greenspun.com/blog/2005/03/07/how-long-is-the-average-internet-discussion-forum-posting/]
}}
{{Cytat
|treść=''Przypuszczam, że powinienem nauczyć się Lispu, ale wydaje się on taki obcy.''
|autor={{Link-interwiki|Paul Graham|Q=Q92650}}, [[listopad 1983]]
|źródło=[http://www.paulgraham.com/iflisp.html]
}}
{{Cytat
|treść=''Można nawet przypuszczać, że Lisp zawdzięcza swoje przeżycie faktowi, że jego programy są listami, co wszyscy, włącznie ze mną, uznawali za wadę.''
|autor=[[John McCarthy (informatyk)|John McCarthy]], twórca Lispu
|źródło=„Early History of Lisp”
}}
{{Cytat
|treść=''Każdy dostatecznie skomplikowany program napisany w C lub Fortranie zawiera tworzone „w biegu”, nieformalnie podane i pełne błędów implementacje połowy cech Common Lispu''.
|autor=Philip Greenspun, zwykle zwana ''{{Link-interwiki|10. reguła programowania Greenspuna|Q=Q4159272}}''<ref>{{cytuj stronę |url = http://philip.greenspun.com/research/ |tytuł = Research |autor = Phillip Greenspun |data dostępu = 2006-10-13}}</ref>
|źródło=
}}
{{Cytat
|treść=''Proszę nie przyjmować, że Lisp nadaje się tylko do programowania Animacji i Grafiki, SI, Bioinformatyki, B2B i E-Commerce, Zbierania Danych, aplikacji EDA/Semiconductor, Systemów Eksperckich, Finansów, Inteligentnych Agentów, Zarządzania Wiedzą, Mechanicznych CAD, Modelowania i Symulacji, Naturalnych Języków, Optymalizacji, Badań i Rozwoju, Analizy Ryzyka, Planowania, Telekomunikacji i Tworzenia Stron WWW tylko dlatego, że te rzeczy zostały wymienione na liście.''
|autor={{Link-interwiki|Kent Pitman|Q=Q6391859}}
|źródło=
}}
{{Cytat
|treść=''Lisp z wyglądu przypomina owsiankę z wmieszanymi obciętymi paznokciami.''
|autor=[[Larry Wall]], twórca [[Perl]]a
|źródło=
}}
{{Cytat
|treść=''Lisp będący najpotężniejszym i najprzyzwoitszym z języków, to język, który projekt GNU zawsze preferuje.''
|autor=[[Richard Stallman]]
|źródło=
}}
{{Cytat
|treść=''Najwspanialszy język programowania, jaki kiedykolwiek zaprojektowano.''
|autor=[[Alan Kay]]
|źródło=
}}
{{Cytat
|treść=''„[[Emacs]]” jest napisany w Lispie, który jest jedynym pięknym językiem programowania.''
|autor=[[Neal Stephenson]]
|źródło=''{{Link-interwiki|In the Beginning...was the Command Line|Q=Q8775712}}''
}}
{{Cytat
|treść=''Programista Lispu zna wartość wszystkich rzeczy, ale nie zna kosztu żadnej z nich''
|autor=[[Alan Perlis]]
|źródło=''{{Link-interwiki|Epigrams on Programming|Q=Q5382930}}''
}}
{{Cytat
|treść=''Sądzę, że jest to jedyny język programowania, który można szanować pod względem matematycznym, gdyż tylko o nim jestem w stanie udowadniać twierdzenia!''
|autor=[[Gregory Chaitin]]
|źródło=
}}

=== Komiksy ===
Lispowi poświęcono kilka komiksów z serii [[xkcd]]<ref name="xkcd">[http://xkcd.com/224 Lisp], [http://xkcd.com/297/ Lisp Cycles], [http://xkcd.com/312/ With Apologies to Robert Frost].</ref>.

== Zobacz też ==
{{wikisłownik|Lisp}}
* [[Porównanie dialektów Lispu]]

== Przypisy ==
{{Przypisy}}

== Bibliografia ==
* „A History and Description of CLOS”, Jim Veitch. Strony 107-158 ''Handbook of Programming Languages, Volume IV: Functional and Logic Programming Languages'', ed. [[Peter H. Salus]]. 1998 (pierwsze wydanie), Macmillian Technical Publishing, {{ISBN|1-57870-011-6}}.
* „Lisp – opis, realizacja i zastosowania”, Jacek Martinek, stron 204, Wydawnictwa Naukowo-Techniczne, Warszawa 1980
* „Kompilator języka LISP 1.5, Jacek Martinek, M. Stroiński, Prace CO PAN, Warszawa 1974, nr 155
* „System programowania minikomputera K-202 w języku Lisp 1.5. Instrukcja programisty, Poznań Instytut Automatyki Politechniki Poznańskiej 1974
* ''[[Structure and Interpretation of Computer Programs]]'', autorstwa [[Harold Abelson]], [[Gerald Jay Sussman]] i [[Julie Sussman]]. 1996 (drugie wydanie), MIT Press, {{ISBN|0-262-01153-0}}.
* [http://lispers.org/ Lispers.org] – Wybór cytatów o Lispie autorstwa znanych programistów Lispu.
* [http://www-formal.stanford.edu/jmc/history/lisp/node3.html The implementation of LISP], Stanford
* [http://www.gnu.org/gnu/rms-lisp.html My Lisp Experiences and the Development of GNU Emacs], odpis wykładu [[Richard Stallman|Richarda Stallmana]], [[28 października]] 2002 roku, na [[International Lisp Conference|Międzynarodowej Konferencji Lispu]]
* [http://www.defmacro.org/ramblings/lisp.html The Nature of Lisp], DefMacro
* [[Paul Graham]], '' [[Hackers & Painters|Hackers & Painters. Big Ideas from the Computer Age]]'', 2004, O’Reilly, {{ISBN|0-596-00662-4}}.

== Linki zewnętrzne ==
* [https://jcubic.pl/2019/05/jak-zaczac-nauke-lispa.html Jak zacząć uczyć się języka LISP] {{lang|pl}}
* [http://groups.google.com/group/comp.lang.lisp/topics comp.lang.lisp] {{lang|en}} grupa [[Usenet]]owa na [[Google Groups]]
* [http://lisp.org Związek Użytkowników Lispu] {{lang|en}}
* {{Cytuj stronę |url = http://wiki.alu.org/ |tytuł = Wiki Związku Użytkowników Lispu |opublikowany = wiki.alu.org |archiwum = https://web.archive.org/web/20080105030639/http://wiki.alu.org/ |zarchiwizowano = 2008-01-05 |język = en}}, miejsce ogólnych dyskusji na tematy związane z Lispem
* {{Cytuj stronę |url = http://community.computerhistory.org/scc/projects/LISP/ |tytuł = Historia LISPu w Computer History Museum |opublikowany = community.computerhistory.org |archiwum = https://web.archive.org/web/20070506015836/http://community.computerhistory.org/scc/projects/LISP/ |zarchiwizowano = 2007-05-06 |język = en}}
* [http://www.lispmachine.net LispMachine.net – książki i informacje na temat Lispu] {{lang|en}}
* [http://paulgraham.com/onlisptext.html?asdf On Lisp] {{lang|en}}, książka [[Paul Graham|Paula Grahama]]
* [http://www.gigamonkeys.com/book/ Książka „Practical Common Lisp”] {{lang|en}}
* {{Cytuj stronę |url = https://www.psg.com/~dlamkins/sl/contents.html |tytuł = Książka „Successfull Lisp” |opublikowany = psg.com |archiwum = https://web.archive.org/web/20160315022224/https://www.psg.com/~dlamkins/sl/contents.html |zarchiwizowano = 2016-03-15 |język = en}}
* [https://letoverlambda.com/ Książka „Let Over Lambda”] {{lang|en}}
* [http://www.se-radio.net/2008/01/episode-84-dick-gabriel-on-lisp/ Wywiad] {{lang|en}} z [[Richard P. Gabriel|Richarem Gabrielem]] ([[podcast]])
* [https://www.youtube.com/watch?v=G3FDnNZF5uA The History of Lisp and Early Artificial Intelligence] (YouTube) {{lang|en}}
* [http://common-lisp.net/project/lispbox/ Lisp in a Box] {{lang|en}}, użyteczna paczka dla początkujących w Lispie – dla [[Microsoft Windows|Windowsa]] lub [[POSIX|Uniksa]].

{{Języki programowania}}

{{Kontrola autorytatywna}}

[[Kategoria:Lisp| ]]