| Lisp | |
|---|---|
| Sémantika | multiparadigma : objektově orientované , funkční , procedurální programování |
| Jazyková třída | multiparadigmatický programovací jazyk , funkcionální programovací jazyk , procedurální programovací jazyk , reflektivní programovací jazyk [d] , metaprogramovací jazyk [d] a interpretovaný programovací jazyk |
| Objevil se v | 1958 |
| Autor | John McCarthy |
| Vývojář | John McCarthy [1] a Steve Russell [d] |
| Typový systém | silný , dynamický |
| Dialekty |
Common Lisp ( CLOS ), Scheme , Arc , jazyky rozšíření Clojure : AutoLisp a ELisp |
| Byl ovlivněn | Jazyk zpracování informací [d] |
| ovlivnil | Io , Nemerle , Python , Ruby , Smalltalk , Logo , Factor , Perl , Nim |
| Mediální soubory na Wikimedia Commons | |
Lisp ( LISP , z angličtiny LIST Processing language - "List processing language"; moderní pravopis: Lisp ) je rodina programovacích jazyků , programů a dat, ve kterých jsou reprezentovány systémy lineárních seznamů znaků . Lisp byl vytvořen Johnem McCarthym pro práci na umělé inteligenci a stále zůstává jedním z hlavních nástrojů v této oblasti. Používá se také jako prostředek konvenčního průmyslového programování, od vestavěných skriptů až po masově používané webové aplikace, i když jej nelze nazvat populární.
Je to jeden z nejstarších (spolu s Fortran a Cobol ) dnes používaných programovacích jazyků na vysoké úrovni [2] a první jazyk, který se stále používá pro automatickou správu paměti a sběr odpadu [3] .
Tradiční Lisp má systém dynamického typu . Jazyk je funkční , ale počínaje ranými verzemi má také rysy imperativnosti , kromě toho, že má plnohodnotné možnosti zpracování symbolů , umožňuje implementovat objektovou orientaci ; příkladem takové implementace je platforma CLOS .
Jedná se o systémový programovací jazyk pro tzv. stroje Lisp vyráběné v 80. letech 20. století například firmou Symbolics .
Spolu s jazykem Ada prošel Lisp procesem základní standardizace pro průmyslové použití, jehož výsledkem byl dialekt Common Lisp , který byl později standardizován ANSI . Jeho implementace existují pro většinu platforem.
Lisp je jazyk, který nerozlišuje malá a velká písmena . Abeceda jazyka byla původně omezena na tabulku znaků ASCII , některé moderní implementace podporují Unicode .
Základními prvky jazyka jsou symboly, atomy a z nich vytvořené dynamické seznamové struktury - S-výrazy .
Symbol v Lisp je objekt v paměti stroje, což je kolekce „slotů“ – buněk, které ukládají odkazy. Některé sloty mají účel původně definovaný jazykem:
Sada slotů je dynamicky rozšiřitelná a lze ji tedy použít jako seznam vlastností libovolného symbolu (systém slotů můžete libovolně rozšiřovat způsobem vhodným pro řešení problému). Tato reprezentace nám umožňuje považovat symboly za uzly vícesouřadnicové sítě, kde je každá souřadnice zapsána ve svém vlastním slotu.
Atomy jsou symboly a čísla. Čísla nejsou Lisp symboly, protože mohou mít pouze svou vlastní číselnou hodnotu a žádnou jinou. Zároveň lze čísla spolu se symboly zahrnout do seznamů. To je důvod pro spojení těchto dvou pojmů do jedné obecné kategorie.
Základní datová struktura Lisp je dynamický seznam atomů, definovaný rekurzivně jako objekt hlavy a k němu připojený seznam ocasů. Protože hlavou seznamu může být také seznam, je seznam formou reprezentace libovolného stromu (seznam nejvyšší úrovně je sám o sobě kořenem, jeho podseznamy druhé a následujících úrovní jsou uzly, atomy jsou listy). Pro atomy a seznamy jazyk používá extrémně primitivní syntaxi závorek: symbol je reprezentován svým jménem, číslo je reprezentováno jeho hodnotou a seznam je reprezentován sekvencí seznamů a atomů uzavřených v závorkách, s oddělenými po sobě jdoucími atomy. v případě potřeby mezerami.
Seznam je posloupnost prvků jakéhokoli druhu, včetně dalších seznamů. Skládá se například (1 3/7 'foo #'+)z celého čísla, racionálního zlomku, symbolu foo a ukazatele na funkci sčítání. Výrazy jsou reprezentovány prefixovými seznamy : prvním prvkem musí být formulář , tj. funkce , operátor , makro nebo speciální operátor ; další prvky jsou argumenty tohoto formuláře , předané formuláři ke zpracování. Aritmetické operátory se zapisují podle stejného principu, například (+ 4 (* 2 3))dává 10 (v infixové notaci je to 2 * 3 + 4).
Syntaxe ve formě Backus-Naur :
s_výraz ::= atomický_symbol | "(" s_výraz "." s_výraz ")" | seznam seznam ::= "(" s_výraz { s_výraz } ")" atomic_symbol ::= písmeno atom_part atom_part ::= prázdný | písmeno atom_část | číslo atom_část písmeno ::= "a" | "b" | "..." | "z" číslo ::= "1" | "2" | "..." | "9" prázdný ::= " "Charakteristickým rysem programu Lisp je, že v této primitivní syntaxi je popsáno naprosto vše: jak data, tak kód jakékoli složitosti. Tento přístup má dva výsledky:
Jakýkoli program Lisp se skládá ze sekvence výrazů (formulářů). Výsledkem programu je vyhodnocení těchto výrazů. Všechny výrazy jsou psány jako seznamy, což je jedna z hlavních struktur Lisp, takže je lze snadno vytvořit v jazyce samotném. To vám umožní vytvářet programy, které upravují jiné programy nebo makra , což vám umožňuje výrazně rozšířit možnosti jazyka.
Pokročilé implementace Lisp obsahují stovky systémových funkcí, maker a operátorů. Jsou zde uvedeny pouze ty z nich, které tvoří základ práce se seznamy a vytváření funkčních programů v Lispu.
T a NIL Lisp vestavěné konstantní symboly, označující logické pravdivé a nepravdivé. Hodnoty Ta jsou NILvráceny logickými operátory a porovnávacími operátory a funkcemi. Symbol NILmá navíc ještě jeden význam – může označovat prázdný seznam. CAR a CDR Funkce vrátí začátek a konec seznamu: (CAR '(A B C D)) ==>> A(dále v příkladech ==>>znamená, že v důsledku vyhodnocení levé strany interpret Lisp produkuje to, co je na pravé straně) (CAR '((A B)(C D))) ==>> (A B) (CDR '(A B C D)) ==>> (B C D) (CDR '((A B)(C D))) ==>> ((C D)) Všimněte si, že v druhém případě je vrácen seznam v seznamu: konec argumentu je jednoprvkový seznam, který sám o sobě je dvouprvkový seznam. Formálně, v čistém funkcionálním programování, význam hlavy prázdného seznamu je nedefinovaný, ale Lisp (alespoň ve většině dialektech) má konvenci, že jak hlava tak konec prázdného seznamu jsou si rovni NIL. (CAR NIL) ==>> NIL (CDR NIL) ==>> NIL Systémové funkce CARdostaly CDRtak neobvyklá jména z historických důvodů. Stroj IBM 704 , na kterém McCarthy vytvořil úplně první implementaci Lisp, obsahoval instrukce pro modifikaci částí strojového slova. Strojové slovo bylo považováno za strukturu s poli prefix, dekrement, tag a adresa. Funkce CAR(zkratka pro Obsah adresní části rejstříku ) a CDR( Obsah dekrementové části rejstříku ) dostaly své názvy podle těchto polí [5] . V této implementaci byla pole adresy a dekrementace použita k uložení ukazatelů na začátek a konec seznamu. V některých nových implementacích Lisp byla tradiční jména nahrazena FIRSTa REST(angl. „first“ a „remainder“, v tomto pořadí) nebo doplněna těmito synonymy. C*R Zde místo hvězdičky "*" v názvu funkce mohou být 2 až 4 písmena "A" a "D" v libovolné kombinaci. To znamená, že funkce CDDDDR, CADAR, CADDRa tak dále jsou možné. Volání takové funkce je ekvivalentní vnoření odpovídající sady funkcí CARa CDRnapříklad (CADAR '((A B C) D E F))odpovídá (CAR (CDR (CAR '((A B C) D E F))))a vrací hodnotu "B". Potřeba takových podivných funkcí souvisí s často opakovaným úkolem: vytáhnout ze seznamu určitý prvek, jehož pozice je známá. NEVÝHODY Vezme hlavu a konec jako argument a vytvoří z nich seznam nebo tečkovaný pár, pokud jsou argumenty atomy: (CONS 'A '(B C D)) ==>> (A B C D) — připojení atomu k seznamu; (CONS '(A B) '((C D))) ==>> ((A B) (C D)) - přidání seznamu do záhlaví jiného seznamu; (CONS 'A 'B) ==>> (A . B) - vytvoření bodového páru dvou atomů. SEZNAM Tato funkce vrací seznam svých argumentů: (list 1 3/7 'foo) ==>> (1 3/7 'foo) Pokud neexistují žádné argumenty, vrátí se prázdný seznam: (list) ==>> NIL Pokud jsou některé prvky výrazy, je nejprve vyhodnocena jejich hodnota: (list 1 2 (list 1 2)) ==>> (1 2 (1 2)). CITÁT Provozovatel systému QUOTEpotlačí vyhodnocení svého argumentu. Pokud se nepoužívá, interpret Lisp se po obdržení seznamu nebo symbolu na vstupu pokusí jej vypočítat: pro symbol je vrácena jeho hodnota, pro seznam - výsledek volání funkce, jejíž jméno je v hlava seznamu s parametry - konec seznamu. Pokud je nutné, aby interpret nepočítal hodnoty, ale vzal symbol nebo seznam "tak jak je", použijte jej QUOTE. (LIST 1 2 (QUOTE(LIST 1 2))) ==>> (1 2 (LIST 1 2)) (QUOTE (list 1 2 (list 1 2))) ==>> (LIST 1 2 (LIST 1 2)) Vzhledem k tomu, že potlačení je velmi běžná operace, existuje syntaktický cukr , který ji zkracuje - namísto plné formy volání QUOTE můžete před výraz jednoduše umístit apostrof: (LIST 1 2 '(LIST 1 2)) ==>> (1 2 (LIST 1 2)). EVAL Tato funkce je ve skutečnosti interpret Lisp. Protože je opakem QUOTE, hodnotí hodnotu svého argumentu. (EVAL '(LIST 1 2 '(LIST 1 2))) ==>> (1 2 (LIST 1 2)) (EVAL '(LIST 1 2 (EVAL'(LIST 1 2)))) ==>> (1 2 (1 2)) Schopnost přímo a přímo volat interpret, spojená s identitou struktury programu a dat, vám umožňuje generovat a přímo spouštět libovolné Lisp programy v systému bez jakýchkoli omezení. COND Generalizovaná podmíněná konstrukce. Vypadá jako: (COND ((Условие1)(Выражение1)) ((Условие2)(Выражение2)) …) Podmínka1, Podmínka2 a tak dále jsou postupně vyhodnocovány, dokud se další PodmínkaN neukáže jako pravdivá (začne mít hodnotu T). Potom bude proveden odpovídající ExpressionN a jeho hodnota bude vrácena jako hodnota volání COND. Pokud se nenajde pravdivá podmínka, CONDvrátí hodnotu NIL. Je běžnou praxí nastavit poslední podmínku na COND, Tčímž se zajistí, že pokud všechny ostatní podmínky selžou, bude vyhodnocen poslední z výrazů; tak vzniká obdoba větve ELSEpodmíněných operátorů imperativních programovacích jazyků. DEFUN Konstrukce, která umožňuje definovat funkci. Obecný (zjednodušený) formát definice je následující: (DEFUN Имя (Параметр1 Параметр2 …) Выражение1 Выражение2 …) Zde Name je název funkce. Odpovídající symbol, pokud ještě neexistuje, bude vytvořen v systému a definice funkce bude zapsána do jeho funkčního slotu. V budoucnu interpret Lisp, který se setká s Name v záhlaví vypočítaného seznamu, jej interpretuje jako volání této funkce s parametry uvedenými na konci. Parametr1 a tak dále jsou názvy formálních parametrů funkce. Sekvence Expression1, Expression2 a tak dále je posloupnost vypočitatelných výrazů, které mohou používat Parametry a globální systémové proměnné. Když je funkce nazývána Výrazy se vyhodnocují postupně a hodnota funkce bude vrácena jako hodnota vyhodnocená posledním výrazem v pořadí.Speciální operátory umožňují řídit posloupnost výpočtů. S jejich pomocí jsou implementovány větve a smyčky . Operátor umožňuje vyhodnotit jeden ze dvou výrazů v závislosti na splnění podmínky, která je také výrazem. Pokud jeho výsledek není FALSE (not ), vyhodnotí se první argument, jinak druhý. Například vždy vrátí . ifnil(if nil (list 1 2 "foo") (list 3 4 "bar"))(3 4 "bar")
Lisp nevyžaduje, obecně řečeno, explicitně specifikovat typy proměnných, parametrů a funkcí. To ale neznamená, že v Lisp nejsou žádné typy. Lisp používá dynamické typování , kdy datový typ neodkazuje na proměnnou (parametr, funkci), ale na hodnotu . To znamená, že proměnná může při absenci speciálních specifikací obsahovat hodnotu libovolného datového typu a v různých časech mít hodnoty různých typů. Typy hodnot jsou určeny tím, jak jsou tyto hodnoty vytvořeny. Například ve výrazu (CONS 10 (CONS 2.01 (CONS 'A (CONS "abc" NIL))))ve stejném (prvním) parametru CONSobdrží stejná funkce ( ) postupně celé číslo , číslo s plovoucí desetinnou čárkou , atom a řetězec.
Pokročilé moderní systémy Lisp, včetně standardního Common Lisp, mají velkou sadu vestavěných datových typů organizovaných v hierarchickém systému, ve kterém může mít typ více supertypů a více podtypů. Kořenem hierarchie je vestavěný typ T, nadtyp všech typů, konečným typem hierarchie je typ NIL, podtyp všech typů.
Obrázek vpravo ukazuje fragment této hierarchie: nadtyp pro hodnoty číselných typů je NUMBER, jeho podtypy - RATIONALa FLOAT, COMPLEX- představují racionální číslo , číslo s plovoucí desetinnou čárkou a komplexní číslo , první z který má zase podtypy INTEGER( celé číslo ) a RATIO( racionální zlomek ), druhý - několik podtypů představujících čísla s plovoucí desetinnou čárkou s různou mírou přesnosti a tak dále.
Do tohoto systému jsou zabudovány i typy vytvořené programátorem.
Protože ne všechny typy hodnot jsou platné pro všechny operace, aplikace operací na některé hodnoty má za následek chyby za běhu. Programátor může tuto funkci buď ignorovat (což způsobí zhroucení programu, pokud narazí na data nezamýšleného typu), nebo použít zpracování výjimek, případně zkontrolovat, zda hodnota, se kterou bude pracovat (například předaná funkci jako parametr) patří k požadovanému typu a v případě neshody zvolte jiný způsob řešení problému nebo převeďte data na požadovaný typ, je-li to možné. Pro práci s typy existují: predikát kontroly TYPEPtypu , funkce určování typu TYPE-OFa pro konverzi typu, pokud ji lze provést, celá sada vysoce specializovaných funkcí a obecná funkce COERCE. Kontrola typů je usnadněna tím, že Lispův typový systém, jak je uvedeno výše, je hierarchický. Kterýkoli z podtypů je kompatibilní s kterýmkoli z jeho supertypů. Například aritmetické operace jsou definovány pro libovolnou kombinaci libovolného typu čísel, takže pro přípustnost použití např. sčítání stačí pomocí predikátu zkontrolovat TYPEP, že operandy jsou typu NUMBER.
( defun SmartPlus ( a b ) ( cond ( ( and ( typep a 'number ) ( typep b 'number )) ( + a b )) ( t nil )))Takže ve výše uvedeném příkladu funkce SmartPlus vrací součet svých argumentů, pokud se jedná o čísla jakéhokoli typu, nebo nulu, pokud alespoň jeden z nich není číslo. V tomto případě bude konkrétní návratový typ záviset na skutečných typech parametrů:
( SmartPlus 1 2 ) ==> 3 ( typ ( SmartPlus 1 2 )) ==> ( INTEGER 0 4611686018427387903 ) ( SmartPlus 1 1.2 ) ==> 2.2 ( typ ( SmartPlus 1 1.2 ) == SINGLE ) -FLOAT ( SmartPlus 2 2/3 ) ==> 8/3 ( typ ( SmartPlus 2 2/3 )) ==> RATIO ( SmartPlus "abc" 20 ) ==> NIL ( typ ( SmartPlus "abc) " 20 )) ==> NULLPoužití dynamického psaní není vždy pohodlné, zvláště když používáte kompilátor. Za prvé, absence omezení typů, ke kterým mohou patřit hodnoty proměnné nebo parametru, snižuje efektivitu kompilace. Za druhé, neumožňuje staticky (během kompilace, nikoli provádění programu) detekovat chyby související s porušením konzistence typu. V situacích, kdy jsou tyto nepříjemnosti významné, Lisp umožňuje pomocí speciálního operátoru DECLAREspecifikovat typy parametrů a proměnných a specifikovat je s potřebnou přesností (můžete zadat jak konkrétní typy, například RATIOnebo SHORT-FLOAT, tak nadtypy libovolného stupně obecnosti, například, NUMBER).
Lisp byl původně navržen jako funkcionální programovací jazyk s určitými nezbytnými funkcemi zavedenými z důvodů snadného praktického použití. Zvolený formalismus a množina primitiv, na nichž je jazyk založen, však umožnily jeho rozšíření různými směry. Za desítky let fungování a vývoje jazyka pohltil téměř všechny existující programovací metodiky a v současnosti jej lze považovat za jeden z nejvýkonnějších vysokoúrovňových multiparadigmatických jazyků.
Funkční paradigma je „původní“ pro Lisp, protože základem jeho architektury je Churchův lambda kalkul . Ve skutečnosti to bylo s Lispem, kdy funkcionální programování začalo jako praktická metodologie pro vývoj softwaru. Lambda výrazy jsou plnohodnotné jazykové objekty v Lisp, umožňující nejen přímé volání, ale také přiřazení, uložení jako hodnotu symbolu, předání jako parametr volání a ve výsledku návrat. Lisp tedy podporuje funkcionály, tedy funkce, které berou jako parametry a jako výsledek vracejí další funkce.
V různých dialektech Lisp je přístup k povaze funkcí jako jazykových objektů poněkud odlišný. V Common Lisp jsou funkce a výrazy lambda samostatnou kategorií programových objektů, pro které existují specifická pravidla a omezení; konkrétně to znamená, že symbol má oddělené sloty pro hodnotu a pro funkci spojenou s tímto symbolem, a v tomto smyslu funkce není přesně stejná jako datový prvek. V jiných dialektech, jako je T-Lisp nebo Scheme, jsou funkce tzv. " plnými občany " - mohou být volně přiřazeny k proměnným, předány jako parametry volání a vráceny jako výsledky volání.
Současný standard Lisp, Common Lisp, byl kritizován zastánci „čistého“ funkčního programování, protože ne všechna jeho funkčnost je teoreticky „čistá“. To je pravda, protože Common Lisp byl navržen jako univerzální průmyslový jazyk a v řadě případů byly úvahy o praktické účelnosti záměrně upřednostňovány před úvahami o teoretické čistotě. Přesto Lisp byl a zůstává funkčním programovacím jazykem.
Zpočátku má syntaxe Lisp schopnost popsat algoritmy vypsáním sekvence požadovaných akcí. Spočívá v takzvaném „implicitním PROGN“ podporovaném ve struktuře Lispových volání lambda: na místo, kde by měl být umístěn příkaz, který tvoří základ lambda výrazu, nelze napsat jeden, ale několik příkazů, a výsledek volání lambda bude výsledkem posledního z nich. Lisp tedy podporuje implicitní sekvenční provádění operací. Kromě implicitního PROGN jsou podporovány explicitní imperativní mechanismy pro imperativní programování:
Common Lisp má zvláštní místo v makru systému LOOP. Umožňuje vám vytvořit fragment v programu Lisp napsaném v programovacím jazyce s obvyklou imperativní strukturou a infixovou notací operátorů.
Nejjednodušší možností programování maker, které je k dispozici v jakékoli implementaci Lisp, je schopnost přímo volat interpret (funkce EVAL ) a předat mu jako programu jakoukoli strukturu seznamu. To umožňuje programu nejvyšší úrovně fungovat jako makrogenerátor, tedy generovat spustitelný kód, který bude následně spuštěn. Například:
( defun name ( name lv ) ( eval ( cons 'defun ( cons name ( cdr lv ))))) ( name 'add ' ( lambda ( x y ) ( + x y )))) ( přičtěte 5 7 ) ==>12Zde funkce назватьvytvoří novou definici funkce z názvu, který jí byl předán, a výrazu lambda a poté tuto definici provede pomocí eval. V důsledku toho сложитьse v systému objeví nová funkce (v tomto příkladu funkce ), kterou lze zavolat obvyklým způsobem.
Tato funkce se však používá jen zřídka kvůli její těžkopádnosti. Mnohem častěji se používá makrosystém . Moderní varianty Lisp, včetně standardu Common Lisp, mají pokročilé funkce pro vytváření a používání maker . Deklarace makra v Lisp je syntakticky podobná deklaraci funkce (jediným rozdílem je použití klíčového slova defmacro namísto defun v deklaraci), ale chování makra je výrazně odlišné: každé volání makra je „rozšířeno“ v době, kdy je program přeložen, generuje kód, který se za běhu provádí následovně: jako by byl napsán přímo na místě volání. Dalším rozdílem mezi makry a běžnými funkcemi je to, že jejich argumenty se ve výchozím nastavení nevyhodnocují. Implementace výše uvedeného příkladu jako makra by mohla vypadat takto:
( defmacro name ( name lv ) ( cons 'defun ( cons name ( cdr lv )))) ( name add ( lambda ( x y ) ( + x y )))) ( přičtěte 12 8 ) ==>20Jsou zde dva viditelné rozdíly: definice makra neobsahuje žádné volání evala apostrofy před parametry se při jejím volání nepoužívají, protože parametry makra se nevyhodnocují. Mnohem důležitější je ale jiný rozdíl: pokud v prvním příkladu dojde ke konstrukci nové funkce během provádění programu, pak se expanze makra provede během překladu programu, takže kompilátor dostane příležitost zpracovat funkci сложить. Syntaktické chyby při vytváření funkcí v makrech jsou také detekovány nikoli během provádění programu, ale dokonce i ve fázi překladu.
Řada implementací Lisp navíc podporuje tvorbu tzv. „read macros“ – maker, která přímo transformují text programu. Makra umožňují transparentně definovat nové jazykové konstrukce a dokonce rozšířit syntaxi jazyka. Druhá možnost se aktivně využívá při implementaci metod a programovacích nástrojů Lisp, které v něm nejsou zpočátku podporovány.
Lisp nebyl navržen jako objektově orientovaný jazyk. Samotné objektově orientované programovací paradigma bylo vyvinuto o dekádu a půl později než Lisp, ale když se objevilo a stalo se populární, byly do tohoto jazyka přidány objektové schopnosti.
Díky základní sadě funkcí Lisp je přidání objektově orientovaného subsystému do Lisp nejen možné, ale také snadné. Vzhledem k přítomnosti vlastností (slotů) pro symboly Lisp nativně podporuje zapouzdření . Funkční vlastnosti Lisp (podpora funkcionalít, přiřazování funkcí proměnným a jejich ukládání do vlastností symbolů) umožňují asociovat kód (metody) s daty (objekty). Konečně dynamická povaha jazyka v kombinaci s výše uvedenými vlastnostmi zajišťuje polymorfní chování kódu a dat v programu. Jedinou součástí systému OOP, která se v základním Lisp nenachází, je dědičnost, ale lze ji bez problémů implementovat. Lisp tedy obsahuje všechny prvky, na kterých je technologie OOP založena, a implementace její podpory v jazyce spočívá ve vytvoření odpovídajících syntaktických prvků. Díky vyvinutému makro mechanismu je lze přidávat pomocí samotného jazyka, bez nutnosti rozšiřovat základní syntaxi a upravovat překladače. Jednoduchý a elegantní příklad vytvoření vlastního OOP subsystému v Lisp lze nalézt v ANSI Common Lisp od Paula Grahama [6] .
Z komerčně známých objektově orientovaných rozšíření Lisp je třeba zmínit především objektový subsystém Flavours, který byl součástí systému Zetalysp. Tento subsystém poskytoval deklarace tříd (příchuti), jednoduchou a vícenásobnou dědičnost, polymorfní metody tříd, systém interakce objektů podobný Smaltalku předáváním zpráv (implementováno jako volání objektové metody). Dalším příkladem je LOOPS (Lisp Object-Oriented Programming System), objektový subsystém implementovaný v roce 1983 v dialektu Interlisp.
Objektový systém CLOS (Common Lisp Object System), původně vytvořený jako doplněk k Common Lisp a později zahrnutý do jazykového standardu, je podobný Flavors a podporuje v podstatě stejnou sadu funkcí, která je standardní pro téměř jakýkoli moderní objektově orientovaný jazyk. . Využití objektově orientovaného programování v Lisp je spojeno především s řešením problémů modelování a/nebo řízení, které jsou ze své podstaty úspěšně kombinovány s objektově orientovanou technologií. Například jednou z prvních aplikací systému Flavours byla interakce s uživatelským rozhraním s více okny, které je vhodné modelovat jako sadu objektů pro zasílání zpráv.
Autorem Lisp je John McCarthy , který v době vzniku jazyka působil na Massachusetts Institute of Technology (MIT) jako profesor komunikací. Spolu s Marvinem Minskym se zabýval prací na umělé inteligenci, v souvislosti s níž vznikla potřeba vytvořit programovací jazyk adekvátní úkolům řešeným v této oblasti. Práce na tvorbě jazyka provedl McCarthy na MIT v letech 1958 až 1963 , poté se přestěhoval na Stanford University v Kalifornii, kde získal pozici „profesora umělé inteligence“.
Lisp byl založen na raném jazyce IPL vyvinutém Newellem, Shawem a Simonem. IPL byl jazyk pro zpracování seznamů a byl určen k implementaci projektu Logic Theorist, systému umělé inteligence navrženého k automatickému odvozování teorémů matematické logiky. IPL byl spíše nízkoúrovňový jazyk, ale již implementoval takové základní myšlenky, jako je jednotný mechanismus pro ukládání programů a dat ve formě seznamů - hierarchické struktury prvků propojených odkazy (samotná myšlenka seznamové reprezentace znalostí byla vypůjčena z výzkumu v oblasti psychologie a asociativní paměti), stejně jako myšlenka dynamické alokace paměti. Po seznámení s IPL v roce 1956 McCarthyho napadlo implementovat zpracování seznamu IPL ve Fortranu , který byl v té době navrhován v IBM (a pod stejným systémem IBM 704 , se kterým McCarthy pracoval na MIT), ale tento nápad nebyla implementována. McCarthy se později účastnil práce „výboru pro jazyk na vysoké úrovni“, který vyvinul Algol , ale i tam byly jeho návrhy přijaty chladně. V důsledku toho McCarthy přišel s myšlenkou vytvořit nový programovací jazyk.
Zpočátku McCarthy formuloval seznamový formalismus pro popis dat ( S-výrazy ) a na něm založený mechanismus pro popisování výrazů lambda , což umožnilo psát programy jako sady funkcí prezentovaných ve formě seznamu. Jak později napsal McCarthy, původně plánoval použít pro psaní programů samostatný formalismus, odlišný od S-výrazů, ale to se ukázalo jako nadbytečné. Když McCarthy pomocí zápisu svého seznamu popsal, jak bude fungovat tlumočník nového jazyka (formalismus, který by se stal známým jako „Lisp on Lisp“), Steve Russell si všiml, že nyní k vytvoření skutečně fungujícího tlumočníka stačí převést tento zápis do strojového kódu. McCarthy byl k této myšlence skeptický, ale Russell skutečně udělal tuto práci a získal první interpret Lisp pro počítač IBM 704. Později byla myšlenka napsat jazykový překladač na samotný Lisp opakovaně používána, a to nejen ve funkčních a logických jazycích, ale i v imperativních.
Historicky první implementací Lisp, která zahrnovala všechny moderní základní prvky jazyka, byl tlumočník běžící na IBM 704, který se objevil v říjnu 1958. To nám mimochodem umožňuje mluvit o Lisp jako o jednom ze dvou nejstarších jazyků na vysoké úrovni, které se používají od okamžiku stvoření až do současnosti (prvním je Fortran). Kromě toho si Lisp udržel své vedení ještě v dalším ohledu. Faktem je, že aktivní práce s dynamickými seznamy znemožňovala ruční správu paměti, která je v imperativních jazycích zčásti zachována dodnes. Vytváření nových buněk seznamu a seznamů a ukončení používání stávajících programů Lisp jsou tak aktivní, že je téměř nemožné obejít se bez automatického systému správy paměti, který by řídil použití objektů dříve vytvořených v paměti a pravidelně odstraňoval objekty které se přestaly používat, tj. systémy na sběr odpadu . McCarthy musel tento systém implementovat, čímž se Lisp mimo jiné stal také nejstarším dnes používaným programovacím jazykem s automatickou správou paměti a garbage collection.
Později byly vytvořeny implementace pro IBM 7090 a později pro IBM řady 360 a 370. Počítače IBM se ukázaly jako nepohodlné pro práci v interaktivním režimu, v důsledku čehož koncem 50. let malá skupina vývojářů včetně těch, kteří dříve pracovali v IBM, rozdělených do nezávislé společnosti Digital Equipment Corporation (DEC). Jeho prvním produktem byl počítač PDP-1 , původně zaměřený na interaktivní režim provozu. Na tomto stroji byl v roce 1960 implementován interaktivní systém Lisp 1, který obsahuje integrovaný interpret, editor zdrojového kódu a debugger, což umožnilo provádět celý cyklus práce na programu přímo v systému. Ve skutečnosti to bylo první „programovací prostředí“ ve smyslu, které se do tohoto konceptu nyní vkládá. Ve stejné době byl v časopise Communications of ACM publikován McCarthyho článek „Rekurzivní funkce symbolických výrazů a jejich výpočet strojem“, ve kterém byl Lisp popsán jako algebraický formalismus na samotném Lisp. Článek se stal klasikou a formalismus „Lisp on Lisp“ se od té doby stal jedním z nejpoužívanějších v literatuře o teorii programování. Další technologickou novinkou, která se objevila v souvislosti s implementací systému „Lisp 1“, byl mechanismus vynalezený McCarthym, který umožňoval, aby interpret Lisp běžel současně s prováděním běžné výpočetní práce v dávkovém režimu (nyní známý jako „ systém sdílení času").
V roce 1962 byla připravena další verze původního systému Lisp „Lisp 1.5“, ve které byly odstraněny nedostatky první verze objevené během provozu. Její popis vydalo nakladatelství MIT Press jako samostatnou knihu [7] . Protože manuál obsahoval popis implementace systému, stal se základem pro tvorbu systémů Lisp pro mnoho dalších počítačů jak v USA, tak v zahraničí.
Přes používání, někdy docela aktivní, Lisp v evropských a asijských zemích a vytvoření jejich vlastních Lisp systémů tam, většina z běžných dialektů Lisp pochází ze Spojených států.
Mac LispPočínaje počátkem 60. let byl na MIT spuštěn projekt MAC, pod kterým byl vyvinut MacLisp založený na Lisp 1.5, zaměřený především na počítače PDP. MacLisp byl na svou dobu extrémně výkonný, pyšnil se vysokou výpočetní efektivitou a širokou škálou matematických datových typů, včetně vektorů, matic a bitových polí. V rámci příspěvku k vývoji samotného jazyka si lze všimnout čtecích maker a čtecích tabulek, které se objevily v MacLisp, což umožnilo „dokončit“ jazyk a rozšířit jej správným směrem o nové struktury. Do jazyka byly také zahrnuty prostředky pro zpracování výjimek a paralelní zpracování. MacLisp se také stal prvním systémem Lisp, pro který byl implementován vysoce účinný kompilátor .
Systém počítačové algebry Macsyma byl napsán celý v MacLisp , jehož vývoj byl zahájen v rámci projektu MAC v roce 1968. Macsyma zůstala nejpokročilejším systémem svého druhu po mnoho let, s několika dialekty Lisp vytvořenými speciálně pro port Macsyma na jiné platformy. Dalším velmi slavným a stále používaným softwarem původně vyvinutým v MacLisp je celoobrazovkový textový editor Emacs .
Systém MacLisp byl využíván a vyvíjen až do 80. let 20. století, což mělo významný dopad na implementace Lisp, které se objevily v 60. a 80. letech, včetně toho, že se stal jedním ze zdrojů pro návrh standardu Common Lisp. Provoz systému prakticky ustal v 80. letech spolu s ukončením používání počítačů PDP-10/20, na kterých byl původně založen. Systémy vyvinuté na MacLispu a již zmiňované Macsymě a Emacsu toho přežily hodně .
InterlispNa vývoji systémů Lisp se v polovině 60. let podílelo mnoho společností a výzkumných center ve Spojených státech. Interlisp byl výsledkem společného úsilí společností BBN (Bolt, Beranek and Newman Inc.), SDS (Scientific Data Systems) a Xerox. Výzkumné centrum BBN v roce 1966 začalo vytvářet svou implementaci Lisp, zaměřenou na počítače PDP-10 a SDS-930. Verze PDP BBN-Lisp používala hardwarový mechanismus stránkování a přepínání kontextu speciálně navržený tak, aby poskytoval vysoce efektivní sdílení času. BBN-Lisp se stal populární mezi výzkumníky AI a významně přispěl k tomu, že stroje PDP-10/20 zůstaly hlavními nástroji v práci AI až do 80. let 20. století. Začátkem 70. let koupila společnost Xerox Corporation zkrachovalou SDS a uzavřela partnerství s BBN. Ačkoli stroje SDS nebyly příliš komerčně úspěšné, implementace Lisp od BBN byla pro Xerox dostatečně slibná, aby podpořila jeho další vývoj, což vedlo k tomu, že se z BBN-Lisp stal Interlisp .
A v roce 1974 začal Xerox vyvíjet osobní pracovní stanici Alto, původně orientovanou na Lisp. V tomto systému byl poprvé proveden vývoj zařízení a systému strojových instrukcí pro konkrétní programovací jazyk. Na základě Interlisp vznikla zjednodušená verze systému Interlisp-D určená pro stroje Lisp řady 1100 ("potomci" stanice Alto). Tyto stroje jako první implementovaly víceokenní grafické uživatelské rozhraní, využívaly grafiku s vysokým rozlišením a myš.
Systém byl rozsáhle zdokumentován a zahrnoval dobře navržené IDE s editorem zdrojového kódu, debuggerem, interpretem a mnoha vývojářskými pomůckami, čímž se stal jedním z příkladných programovacích prostředí pro systémy sdílení času. V knihovnách systému bylo implementováno více než 500 funkcí, systém disponoval velkým množstvím nastavení, která umožňovala jeho „šití na míru“ uživateli. Implementace Interlisp byly nakonec spuštěny na nejrozšířenějších velkých počítačích s časovým sdílením.
Pokud jde o jazyk samotný, lze poznamenat, že dialekt se všemi jeho charakteristickými rysy byl zafixován již v polovině 70. let 20. století, poté k žádným zásadním změnám jazyka nedošlo. To způsobilo, že systém zaostával za novějším vývojem z hlediska funkčnosti a opravoval některá zastaralá designová rozhodnutí. V důsledku toho měl Interlisp na počátku 80. let potíže jak s kompatibilitou s novými systémy, tak s dalším rozšiřováním. Nejvýraznějšími nedostatky jsou chybějící hierarchie datových typů, objektů a uzávěrů (přesto byl v roce 1983 implementován objektový systém LOOPS, dávající možnost objektově orientovaného programování). Ještě důležitější je, že Interlisp je založen na dynamickém propojení, zatímco všechny nové verze Lisp jsou statické.
PSLLisp přišel do Kalifornie s McCarthym, který se v roce 1963 přestěhoval do Stanfordu . Během několika dalších let byly vyvinuty systémy Lisp 1.6 (přímý potomek „klasického“ Lisp 1.5), UCI Lisp (University of California, Irvine) a Stanford Lisp/360. Odtud spolu s Anthonym Hearnem šla Lisp na University of Utah , kde dělala výzkum v oblasti symbolické matematiky v aplikacích teoretické fyziky. Hearn navrhl vyřešit tyto problémy pomocí Lisp, což vyústilo ve vytvoření systému počítačové algebry Reduce v roce 1968 .
Hearn zveřejnil v roce 1966 specifikaci Standard Lisp, kterou navrhl jako základ pro standardizaci jazyka. Jeho návrh se nesetkal s podporou, protože jej neschválili výzkumníci umělé inteligence, kteří poukázali na řadu pro ně nežádoucích vlastností navrhovaného standardu, zejména na přílišnou vazbu na typy. Na základě této specifikace byl však v Utahu implementován Portable Standard Lisp, PSL. Tato implementace byla použita k vývoji Reduce a portování na různé hardwarové platformy. Konkrétně pro zlepšení přenositelnosti byla do PSL zahrnuta omezená sada systémových funkcí a struktur. Implementace byla založena na středně pokročilém nízkoúrovňovém jazyku podobném Lisp, SYSLisp; jádro PSL bylo napsáno v SYSLisp a zbytek systému byl napsán v samotném PSL. Pro PDP-10 byl implementován překladač SYSLisp a křížový kompilátor napsaný ve stejném SYSLisp, s jehož pomocí bylo možné přenést jádro PSL na jakýkoli jiný hardware. Pomocí této technologie byly PSL a Reduce implementovány na řadě platforem, včetně DEC-10/20, VAX/UNIX, HP9000, Apollo, Wicat, IBM, Cray.
PSL se tak stalo jedním z prvních příkladů implementace techniky „spin-up“ při portování softwarových systémů na novou architekturu, kdy za účelem portování systému je jádro zpočátku napsáno ve strojově nezávislém mezijazyku. , pro které jsou zase vytvořeny implementace na všech cílových platformách. Další podporu PSL provedlo výzkumné centrum společnosti Hewlett-Packard v Kalifornii.
Franz LispMotivací pro Franze Lispa na konci 70. let bylo získat systém Lisp pro nové počítače VAX, aby mohl provozovat systém Macsyma a další software napsaný v Lisp. Vzhledem k tomu, že hlavním cílem bylo přenést Macsymu, byl jako základ vzat MACLisp, nicméně některé zastaralé funkce byly z jazyka vyloučeny a byly přidány nové mechanismy, vypůjčené od Zetalispu vyvíjeného v té době na stejném MIT. Nejvýznamnějšími příspěvky k vytvoření tohoto dialektu byly University of Berkeley , University of Pennsylvania , Bell Labs , Livermore National Laboratory a Carnegie Mellon University . Jednou z hlavních inspirací pro projekt byl profesor Berkeley University Richard Feitman, dříve z MIT a podílející se na vývoji původního systému Macsyma. Mezi tvůrci Franze Lispa bylo několik jeho studentů. Název systému byl zvolen na počest slavného maďarského skladatele Franze Liszta (anglicky: Franz Liszt).
Systém byl implementován v roce 1981 v jazyce C pro VAX 780/11 se systémem UNIX . Překladač zařazený do systému se jmenoval „Liszt“ – příjmení skladatele, který dal jméno dialektu. V roce 1982 byl systém portován na procesor Motorola 68000 , poté na řadu 32bitových osobních platforem, v důsledku čehož se stal nejrozšířenější verzí Lisp pro 32bitové systémy sdílení času a 32bitové minipočítače. a osobní pracovní stanice.
Franz Lisp byl distribuován zdarma pod licencí BSD, ale postgraduální student Berkeley Friedrich Kunze přišel s nápadem vytvořit komerční společnost, která by poskytovala vysoce kvalitní placenou uživatelskou podporu a plnila objednávky na portování Franze Lispa na nový hardware a softwarové platformy. Byla to doba aktivního růstu na počítačovém trhu a vyhlídky vypadaly dobře. Společnost byla zaregistrována v roce 1984 a byla pojmenována Franz Inc. Začátek činnosti společnosti byl poměrně úspěšný, podařilo se jí získat kontrakt na port Franze Lispa na platformu Sun a později - několik dalších podobných nabídek. V roce 1985 však pod tlakem amerického ministerstva obrany začala americká Lisp komunita aktivní přeorientování na nový dialekt – Common Lisp, který se v té době dokončoval. Za těchto podmínek Franz Inc. nemohl najít nové zakázky, byl na pokraji uzavření a byl nucen přejít k vývoji vlastní implementace Common Lisp - Allegro Common Lisp (název byl zvolen pro zachování kontinuity „hudebního“ tématu). Tady vlastně skončila historie Franze Lispa. Původní systém je nyní zcela mimo provoz.
SchémaJazyk Scheme byl vyvinut v roce 1976 na MIT jako součást projektu Lisp Machine, osobní pracovní stanice navržená výhradně z hardwaru, aby bylo možné maximálně využít jazyk Lisp. Zpočátku byl Scheme jen „výzkumným jazykem“, při jehož vývoji se testovaly různé nápady a metody. Cílem bylo implementovat minimální sadu základních funkcí, které by navázáním na tuto sadu zajistily stavbu plnohodnotného Lisp-systému.
Výsledkem je malé a elegantně definované jádro, ale velmi efektivně implementované. Konkrétně Scheme byl prvním dialektem jazyka Lisp, který zaručoval optimalizaci rekurze ocasu. Jazyk implementuje výkonný makro mechanismus, kromě seznamů jsou jako základní konstrukce podporována pole. Charakteristickým syntaktickým rozdílem mezi Scheme a většinou dialektů Lisp je mírně odlišná forma definice funkce. Pokud se ve většině dialektů používá varianta: (DEFUN ИмяФункции (Аргументы) Выражения), pak ve Schématu vypadá zkrácená podoba definice jako (DEFINE (ИмяФункции Аргументы) (Выражения)). (Klíčové slovo a relativní pozice názvu funkce a argumentů se liší). Schéma používá dynamické spojování a implementuje jeden jmenný prostor pro funkce a proměnné, čímž se odlišuje od Common Lisp.
Scheme je jediný „starý“ dialekt jazyka Lisp, který se nadále používá po rozsáhlém přechodu komunity Lisp na standardizovaný jazyk Common Lisp. V současné době existuje několik podporovaných implementací Scheme, včetně bezplatných, existují příklady použití tohoto jazyka jako vestavěného (například používaného jako skriptovací nástroj GIMP Tiny-Scheme). Několik amerických univerzit používá Scheme jako jazyk pro základní výuku programování.
ZetalispZetalisp neboli „Lisp Machine Lisp“ byl vytvořen na MIT v druhé polovině 70. let jako součást projektu Lisp Machine Project financovaného americkou obrannou agenturou DARPA.
Systém byl založen na MacLispu a editoru Emacs, jazyk byl však výrazně aktualizován a doplněn, zejména se v něm objevily nové datové typy, objektově orientovaný subsystém Flavors, na kterém byla interakce programů s víceokénkovým uživatelským rozhraním. je založena na nových direktivních řídících strukturách, částečně převzatých z Interlisp, vícehodnotových funkcích (schopných vracet více než jednu hodnotu běžným způsobem bez předchozího „skládání“ do kontejneru), streamování I/O, jmenné prostory, výkonná knihovna funkcí, včetně matematických, poskytování vektorových a maticových výpočtů a práce s lineárními systémy.
Mnohem více inovací byl proveden samotný programovací systém. Systém byl původně navržen pro práci s grafickým uživatelským terminálem a myší. Implementovalo grafické uživatelské rozhraní s více okny. Systém zahrnoval multiokenní interpret Lisp, částečný překladač, textový editor Zmacs, inspektor datové struktury, debugger, průzkumník stavu systému, editor systémových souborů, editor písem a e-mailový klient Zmail. Systém zahrnoval překladače dalších jazyků vyšší úrovně, konvertor poskytující podporu programů Interlisp a sadu nástrojů vyšší úrovně. Fortran, Pascal, Ada a Prolog, které byly dodány jako součást systému, byly vyvinuty prostředky interakce s programy Lisp, které umožňovaly v případě potřeby vyvíjet a aplikovat softwarové systémy v několika jazycích.
Zpočátku byl projekt zaměřen na vytvoření komerčního produktu. V roce 1979 byly vytvořeny dva podniky - výrobci strojů Lisp: Symbolics a Lisp Machine Inc. (LMI). Poté byly práce na vývoji Zetalisp prováděny těmito firmami samostatně. Nicméně, zatímco tam byly nějaké rozdíly v Lisp strojích sám, pokud jde o jazyk, byly téměř zcela kompatibilní.
NIL a TImplementace MACLisp na stroji VAX na samotném MIT začala v roce 1979. Projekt se jmenoval NIL (současně zkratka "New Implementation of Lisp" - "New Lisp Implementation" - a standardní atom Lisp "NIL", označující v závislosti na použití logickou nepravdu nebo prázdný seznam). NIL měl poměrně velké jádro napsané v assembleru VAX, na kterém byl postaven systém Lisp pomocí stejné metody odvíjení. NIL lze do jisté míry považovat za „odpověď na Franze Lispa“, protože jedním z cílů projektu bylo stejné portování systému Macsyma na VAX. NIL si hodně vypůjčil od Zetalispu, včetně systému Flavours, který mění systém Lisp na objektově orientovaný. V roce 1981 se skupina zapojená do projektu NIL rozpadla kvůli nesmiřitelným rozdílům v ideologii vytvářeného systému. I přes kolaps od roku 1982 vycházejí pravidelné aktualizace systému a dočkal se poměrně znatelné distribuce. V 80. letech byl NIL často používán v organizacích, které měly stroje VAX i Lisp, protože mezi NIL a Zetalisp nejsou žádné zásadní ideologické rozdíly, ačkoli Zetalisp je mnohem bohatší na funkce.
Skupina vývojářů, kteří se oddělili od projektu NIL, začala vytvářet vlastní verzi systému Lisp, která dostala ironický název „ T “ (současně – od „True Lisp“ – „Real (true) Lisp“ a další standardní atom Lisp "T", označující logickou pravdu, tedy opak "NIL"). Vývoj tohoto dialektu byl proveden na Yale University v letech 1982-1984. Na rozdíl od „starých“ systémů používal dialekt T standardně vazbu statické proměnné, navíc jeho tvůrci zavedli implementaci funkcí jako „plnoobčané“, což znamená, že funkce lze přiřazovat proměnným bez speciálních syntaktických prostředků a bez omezení a vráceny jako hodnoty jiných funkcí. T-Lisp, na rozdíl od NIL, měl poměrně malé jádro napsané ve strojovém jazyce. Vývojáři použili techniku "spin-up", ručně portovali jádro na nové platformy a implementovali zbytek systému přímo v Lispu, s očekáváním, že vysoce výkonný překladač poskytne finálnímu systému lepší výkon než ruční implementace velkého stroje. jazykové jádro.
Kontroverzním bodem v T-Lisp bylo rozhodnutí autorů aktualizovat a systematizovat názvy funkcí systému. Takže například názvy všech predikátů bez výjimky končily otazníkem, „historicky ustálené“ standardní názvy elementárních funkcí byly nahrazeny mnemotechnickými, odpovídajícími tomu, co funkce dělá. Například funkce CARa CDR, které vracejí začátek a konec seznamu, jsou pojmenovány FIRSTa REST(angl. „first“ a „remainder“). Nepochybnou výhodou tohoto rozhodnutí bylo usnadnění učení, zjevnou nevýhodou byla nekompatibilita se všemi ostatními dialekty jazyka. V důsledku toho museli tvůrci systém ještě následně doplnit o sadu maker, která uvádějí systém pojmenování do souladu se standardem Common Lisp. Určitě významný vliv, který měl dialekt Scheme na T. Obecně se T-Lisp ukázal jako poměrně jednoduchý, elegantní a mobilní systém, který byl implementován pro VAX a portován na mnoho 32bitových pracovních stanic.
V první polovině 80. let se v komunitě Lisp vyvinula situace, kterou někteří autoři srovnávali s Babylonskou věží : více než tucet velkých dialektů Lisp existovalo a vyvíjelo se paralelně, zatímco celkový počet implementací vzájemně neslučitelných byl výrazně větší. Podobná situace byla v té době pozorována u většiny běžných programovacích jazyků, v případě Lisp však byla situace ztížena skutečností, že jazyk byl původně navržen jako libovolně rozšiřitelný, což vyvolalo rozvoj jeho schopností v různých dialektech ve výrazně různé směry. Jestliže v počáteční fázi, kdy se Lisp používal téměř výhradně v laboratořích a ústavech, rozmanitost dialektů nijak zvlášť nepřekážela a byla dokonce poněkud užitečná, protože přispěla k rychlému rozvoji jazyka, pak v 80. letech 20. století potřeba průmyslového rozvoje v Lisp, množství implementací se stalo brzdou, protože to vedlo k masivní duplikaci vývoje a rozptýlení sil na podporu mnoha systémů Lisp.
Pokusy o standardizaci Lisp byly činěny téměř od jeho vzniku (první návrh standardizace pochází z roku 1960), ale kvůli nejednotnosti a značným rozdílům v potřebách zainteresovaných vývojových skupin nebyl žádný z návrhů přijat. Ve druhé polovině 70. let odvedlo americké ministerstvo obrany skvělou práci při analýze situace ve vývoji vojenského softwaru, načež zorganizovalo soutěž na vývoj nového vysokoúrovňového jazyka pro vestavěné systémy, kterým se stal jazyk Ada . Ada však původně nebyla určena pro umělou inteligenci a zpracování znaků, v důsledku čehož byla americká armáda nucena povolit pro takový vývoj vhodnější jazyk. Ministerstvo obrany USA proto organizačně a finančně podpořilo vytvoření průmyslového standardu pro jazyk Lisp, který přijalo jako doplňkový nástroj pro vývoj softwaru pro vojenské aplikace.
Původní návrh standardu začal na Carnegie Mellon University na základě interního projektu Spice Lisp, původně také zaměřeného na vývoj systému Lisp pro pracovní stanici. Od samého počátku dostal projektovaný standard název „Common Lisp“ („Common Lisp“), zdůrazňující cíl vývoje – získat jediný základní jazyk, na jehož základě by bylo možné vytvářet softwarově kompatibilní systémy. Na vývoji a úpravě normy se podílelo asi 80 specialistů z amerických univerzit, laboratoří a firem. Poprvé probíhal vývoj na dálku prostřednictvím počítačové sítě ARPANET , přes kterou bylo přeneseno přes 3000 zpráv. Standardní vývojový proces skončil v roce 1984. Jeho výsledek byl zaznamenán v prvním vydání Guy Steele's Common Lisp: the Language.
Příchod Common Lisp zpomalil vytváření nových dialektů jazyka. "Staré" dialekty nadále existovaly, ale jak platformy, na kterých běžely, přestaly být používány, stejně tak se přestaly používat odpovídající systémy Lisp. Většina z nich zanikla v letech 1985-1995. Nový vývoj byl již proveden v Common Lisp. V následujících letech se však objevilo několik nových lispských dialektů, z nichž většina šla cestou zjednodušení a byla orientována na mikropočítače.
ISLISPISLISP je specifikace Lisp vyvinutá v 90. letech a publikovaná organizací ISO v roce 1997 [8] . Specifikace byla aktualizována v roce 2007 [9] . ISLISP je pokus o standardizaci jádra jazyka Lisp konsolidací existujících a rozvíjejících se komerčních dialektů jazyka Lisp v době jeho vzniku. Dialekt je v mnoha ohledech podobný Common Lisp (lexikální rozsah, samostatné jmenné prostory pro funkce a proměnné, poměrně výkonný systém datových typů, podpora komplexních typů, makrosystém, objektový systém), ale rozsahem menší. Pro rok 2018 existuje asi tucet hlavních implementací ISLISP, které jsou vydány převážně pod proprietárními licencemi.
openlispDialekt vytvořený Christianem Julienem v roce 1988. Původně se jmenoval MLisp, v roce 1993 byl přejmenován na OpenLisp. Název symbolizuje použití otevřených standardů, ale nemá nic společného s Open Source Initiative nebo svobodným softwarem : systém je distribuován pod proprietární licencí.
Plně vyhovuje specifikaci ISLISP , navíc implementuje řadu funkcí, které v tomto standardu chybí. Interaktivní vývoj ( REPL ) je možný v prostředí Emacs . Kromě interpretru systém obsahuje kompilátor, který převádí zdrojový kód do LAP (Lisp Asssembly Program, nízkoúrovňový kód podobný assembleru ve formátu seznamů Lisp) a generátor kódu, který překládá program LAP do zdrojového kódu. v jazyce C. Velká pozornost je věnována interakci s C/C++ a Java kódem, podpoře vestavby do softwarových systémů jako embedded jazykový interpret. Systém je nadále vyvíjen a podporován, existují verze pro většinu dostupných operačních systémů a hardwarových platforem.
Pico LispPicoLisp je bezplatná implementace Lisp navržená pro použití na Linuxu a dalších systémech POSIX . Projekt se objevil na konci 80. let 20. století, jeho cílem bylo vytvořit minimalistický, ale praktický systém Lisp pro osobní počítače.
Z jazykové stránky PicoLisp rozlišuje velká a malá písmena, podporuje UTF-8 a je extrémně jednoduchý. Jádro podporuje pouze tři datové typy: čísla, řetězce a seznamy. Byly zavedeny syntaktické prostředky pro řízení vyčíslitelnosti parametrů, formulář nabídky byl rozšířen na neurčitý počet parametrů. Toto řešení odstranilo potřebu speciální syntaxe pro makra a výraz lambda. Struktury a pole nejsou podporovány, existuje ekonomicky provedený, ale výkonný objektový subsystém. Na rozdíl od Common Lisp jazyk používá dynamickou vazbu parametrů.
Prostředí PicoLisp nemá kompilátor (jedná se o zásadní rozhodnutí, kvůli kterému došlo k mnoha zjednodušením v jazyce), ale obsahuje vestavěný aplikační server a úložný subsystém [10] . Implementováno přímé volání externích funkcí napsaných v C a také interakce s kódem Java. Dialekt se dále vyvíjí, pravidelně vycházejí nové verze programovacího prostředí pro několik platforem.
EuLisp
Dialekt vyvinutý od roku 1985 komunitou evropských vývojářů Lisp a uživatelů z akademické sféry a průmyslu. Lze to považovat za jakousi „evropskou odpověď na Common Lisp“ – alternativní pokus o vytvoření jednotného dialektu jazyka Lisp vhodného pro širokou škálu úkolů. Cílem projektu bylo vytvořit efektivní, kompaktní a nezatížený jazyk „Lisp minulosti“. Jednou z priorit při vývoji tohoto projektu bylo přidat do Lisp objektově orientované funkce.
Dialekt podporuje definici modulů s lexikálním rozsahem, uzávěry s dynamickou vazbou, jednotný jmenný prostor pro proměnné a funkce, jako v Scheme, vestavěnou podporu pro souběžnost, objektový systém s jednoduchou a vícenásobnou dědičností. Charakteristickým rysem projektu je rozdělení jazyka do dvou úrovní, Level-0 a Level-1, některé funkce jsou dostupné pouze na úrovni 1, například vícenásobná dědičnost a meta-objekty.
Poslední oficiální specifikace (verze .99) byla vydána v roce 1993, její neoficiální revize (verze .991) v roce 2010. První interpret byl vydán v roce 1990, v letech 1990-2000 bylo vytvořeno několik implementací, jejichž vývoj se do roku 2011 zastavil.
newLispDialekt vyvinutý v roce 1991 Lutzem Müllerem pro použití jako skriptovací jazyk na pracovních stanicích Sun se systémem SunOS a FreeBSD. V současné době k dispozici na 32bitových a 64bitových platformách Intel pod FreeBSD, Linux, Windows, Mac. Liší se jednoduchostí, malým objemem, dynamickým rozsahem proměnných, má řadu funkcí v syntaxi. Podporuje objektový systém FOOP, nástroje pro meziprocesovou komunikaci a další. Prostředí obsahuje interpret, mini-IDE s editorem kódu a emulátorem terminálu pro interaktivní vývoj, knihovny pro vývoj webu a síťování přes protokoly TCP a UDP.
RaketaVyvíjen od roku 1994 společností PLT Inc. dialekt původně pojmenovaný PLT Scheme. Je to potomek dialektu Scheme, ale výrazně jej rozšiřuje. Jedním z cílů vytvoření Racketu bylo poskytnout platformu pro vývoj a implementaci doménově specifických jazyků. Jeho charakteristickým rysem je velmi výkonný makrosystém, který umožňuje vytvářet nové syntaktické konstrukce a dokonce i jazyky. Systém modulů zároveň zajišťuje použití v jediném programu prvků napsaných v různých dialektech s různou sémantikou.
Implementace zahrnuje kompilátor, runtime systém, JIT kompilátor, integrované vývojové prostředí se sadou nástrojů, knihovny. IDE DrRacket, napsané v samotném Racketu, obsahuje profiler, debugger a systém testování jednotek. K dispozici jsou knihovny, které podporují systémové a síťové programování, vývoj webových aplikací, jednotné rozhraní operačního systému, rozhraní pro volání externích funkcí, několik variant regulárních výrazů, generátory analyzátorů a analyzátorů, nástroje pro logické programování a pokročilé grafické uživatelské rozhraní. Platforma je implementována pro Windows, MacOS, Linux a další varianty UNIXu. Je distribuován jako svobodný a otevřený software pod licencí GNU Lesser General Public License (LGPL). Pro balíčky a rozšíření vytvořené komunitou je udržováno centralizované úložiště.
Používá se jako výzkumný (hlavně jako platforma pro vývoj jazyků a programovacích nástrojů), vzdělávací, skriptovací , průmyslový jazyk (zejména pro vývoj videoher). V tutoriálu používá tutoriál Bootstrap v konceptu "učení pomocí kódování her".
ObloukArc je dialekt vytvořený Paulem Grahamem . Cílem autorem deklarovaného projektu je vytvořit jednoduchý, na minimální množině ekonomicky definovaných entit, systém Lisp se sadou prakticky užitečných knihoven, zaměřený na profesionální použití a umožňující efektivní „Lisp hacky“ (různé výpočetní triky založené na vlastnostech Lisp). Autor v zásadě odmítl podporovat některé technologie v Arcu, zejména OOP , protože se domníval, že jsou potřebné pouze při vývoji ve velkých organizacích a samy o sobě nedávají skutečný užitečný efekt. Vývoj byl oznámen v roce 2001, první veřejná verze se objevila v roce 2008. První implementace jazyka byla napsána v prostředí Racket. Od roku 2009 se původní systém prakticky přestal vyvíjet a nyní vývoj Arcu pokračuje v několika vidlicích .
V posledních desetiletích se rozšířily jazyky, které využívají automatickou správu paměti, kompilaci do mezikódu a jeho provádění ve virtuálním stroji, jako je Java, Python, C# a další. Bylo také vytvořeno několik dialektů Lisp, orientovaných na provádění v dynamických prostředích jiných jazyků. Tyto dialekty jsou schopny pracovat přímo s knihovnami odpovídajícího jazykového prostředí a interagovat s programy v jiných jazycích, které běží ve stejném prostředí. Mezi nimi:
V zásadě byly ideologické základy standardu ovlivněny MACLispem a jeho dialekty, velké množství funkcí bylo vypůjčeno z InterLISPu a nových systémů jako Zetalisp a NIL.
Common Lisp je jazyk se statickou proměnnou vazbou, tradiční reprezentací funkcí (funkce nejsou "plnoobčany"), podporuje makra, funkcionály, lexikální uzávěry. To znamená, že z hlediska funkční části jazyka obsahuje celou sadu syntaktických prostředků, která se v Lisp za poslední čtvrtstoletí vyvinula a je dostačující pro jakoukoli aplikaci funkcionálního programování a rozšíření jazyka v jakémkoli požadovaný směr. Systémové funkce v Common Lisp si zachovávají své tradiční názvy, ale mnoho z nich má synonyma s popisnějšími názvy, například funkce CAR(dostat se na začátek seznamu) a CDR(dostat se na konec seznamu) mají synonyma pro FIRST(„první“ ) a REST("zbytek") .
Jelikož cílem bylo vyvinout systém vhodný pro co nejširší spektrum aplikací, je specifikace výrazně rozšířena o funkce, syntaktické prostředky a mechanismy, které nejsou charakteristické pro původní Lisp. Tak například byly do jazyka přidány téměř všechny syntaktické konstrukce existující v imperativních jazycích, včetně několika typů smyček. Objektový systém CLOS (Common Lisp Object System) nebyl původně součástí standardu, ale stal se jeho součástí později. Common Lisp je vhodný pro psaní programů ve funkcionálním i direktivním stylu, je možné zobecňovat programování (pomocí standardních maker), produkční programování, existují nástroje pro organizaci logiky, objektové programování a programování řízené daty. Specifikace neobsahuje podrobný popis programovacího prostředí, definuje pouze v nejobecnějších pojmech jeho složení a principy interakce prvků.
Kritici nového standardu poukazovali na jeho nabubřelost a přílišný důraz na praktické požadavky, což vedlo k porušení „funkční čistoty“ Lisp a zvětšení velikosti systému Lisp. Přesto pod tlakem amerického ministerstva obrany a částečně i za jeho finanční podpory vznikly v druhé polovině 80. let implementace Common Lisp pro téměř všechny běžné platformy.
Velká revize normy, publikovaná v roce 1984, proběhla v roce 1990 :
V roce 1995 byl Common Lisp standardizován organizací ANSI . Norma prakticky zopakovala specifikaci z roku 1990, změny jsou drobné a spočívají především v přidávání, odebírání a přejmenovávání operátorů a systémových proměnných a změnách systémových volání. Můžeme si všimnout vzhledu v Common Lisp typu boolean (boolean), jehož hodnoty mohou být pouze NIL a T.
Příklad programu, který zobrazuje zprávu " Ahoj, světe!" »:
( formát t "Ahoj světe!~%" )Varianty Quine (program, který vydává svůj zdrojový kód) v Lisp:
(( lambda ( x ) ( seznam x ( seznam 'citát x ))) ( citát ( lambda ( x ) ( seznam x ( seznam 'citát x )))))) (( lambda ( x ) ( seznam x ( seznam 'citát x ))) ' ( lambda ( x ) ( seznam x ( seznam 'citát x )))))Oba budou fungovat ve většině dialektů Lisp, včetně Scheme . Který z nich bude přesnější, závisí na implementaci systému Lisp: v některých se při zobrazení hodnoty seznamu pro zobrazení blokování výpočtu zobrazí speciální operátor quotejako celé jméno (pro ně je vhodná první možnost) , v ostatních - jako apostrof (druhá možnost). Quine's Common Lisp verze pomocí backquote:
(( lambda ( x ) ` ( , x ', x )) ' ( lambda ( x ) ` ( , x ', x )))Iterativní verze funkce pro určení N- tého Fibonacciho čísla pomocí makra Loop:
( defun fibonacci ( n ) ( opakování smyčky n pro a = 0 pak b a b = 1 pak ( + a b ) nakonec ( návrat b )))Rekurzivní verze funkce N-tého Fibonacciho čísla:
( defun fibonacci ( n ) ( if ( > n 1 ) ( + ( fibonacci ( - n 1 )) ( fibonacci ( - n 2 ))) n ))Rekurzivní funkce pro výpočet libovolné mocniny celého čísla (algoritmus s logaritmickou dobou provádění a hloubkou rekurze):
( defun power ( x n ) ( cond ( ( minusp n ) ( / 1 ( power x ( - n )))) ( ( nula n ) 1 ) ( ( evenp n ) ( power ( * x x ) ( / n 2 ))) ( t ( * x ( mocnina ( * x x ) ( / ( - n 1 ) 2 ))))))Zde se používají systémové predikáty ZEROP - kontrola rovnosti na nulu, MINUSP - kontrola negativity, EVENP - kontrola parity.
| 1955 | 1960 | 1965 | 1970 | 1975 | 1980 | 1985 | 1990 | 1995 | 2000 | 2005 | 2010 | 2015 | 2018 | ||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Lisp 1.5 | Lisp 1.5 | ||||||||||||||||||||
| Maclisp | Maclisp | ||||||||||||||||||||
| Interlisp | Interlisp | ||||||||||||||||||||
| ZetaLisp | Lisp Machine Lisp | ||||||||||||||||||||
| Systém | Systém | ||||||||||||||||||||
| NULA | NULA | ||||||||||||||||||||
| Lisp obecný | Lisp obecný | ||||||||||||||||||||
| LeLisp | Le_Lisp | ||||||||||||||||||||
| T | T | ||||||||||||||||||||
| Emacs Lisp | Emacs Lisp | ||||||||||||||||||||
| AutoLISP | AutoLISP | ||||||||||||||||||||
| openlisp | openlisp | ||||||||||||||||||||
| Pico Lisp | Pico Lisp | ||||||||||||||||||||
| EuLisp | EuLisp | ||||||||||||||||||||
| ISLISP | ISLISP | ||||||||||||||||||||
| nový LISP | nový LISP | ||||||||||||||||||||
| raketa | raketa | ||||||||||||||||||||
| Lstivost | GNU Guile | ||||||||||||||||||||
| Vizuální LISP | Vizuální LISP | ||||||||||||||||||||
| Clojure | Clojure | ||||||||||||||||||||
| Oblouk | Oblouk | ||||||||||||||||||||
| LFE | LFE | ||||||||||||||||||||
| Hy | Hy | ||||||||||||||||||||
Rozsah jazyka Lisp je rozmanitý: věda a průmysl, vzdělávání a medicína, od dekódování lidského genomu až po systém návrhu letadel. První oblasti aplikace jazyka Lisp byly spojeny se symbolickým zpracováním dat a rozhodovacími procesy. Nejoblíbenějším dialektem Common Lisp je dnes univerzální programovací jazyk. Je široce používán v různých projektech: internetové servery a služby, aplikační servery a klienti spolupracující s relačními a objektovými databázemi, vědecké výpočty a herní programy.
Existují specializované dialekty Lisp určené pro specifické aplikace, například Game Oriented Assembly Lisp (GOAL) byl vytvořen pro psaní vysoce dynamických trojrozměrných her, je v něm napsána celá série her Jak and Daxter .
Jedním z využití Lisp je jeho použití jako skriptovacího jazyka , který automatizuje práci v řadě aplikačních programů, včetně:
V případě jazyka Lisp je obtížné stanovit jasnou hranici mezi dialektem a jazykem potomka, protože různé dialekty jazyka Lisp, vytvořené za více než půl století jeho existence, se mohou výrazně lišit a být neslučitelné. Na druhou stranu Lisp už jen díky svému stáří měl ten či onen vliv na velké množství jazyků, a to nejen funkčních. Pokud vezmeme v úvahu přímé potomky Lisp pouze jazyky, které si zachovaly obecnou strukturu programu, ale jsou syntakticky nekompatibilní s Lisp, pak můžeme rozlišit:
Počátkem 70. let byla rozpoznána omezení uložená systémem sdílení času uživatelům interaktivního softwaru (který zahrnuje jak systémy Lisp, tak většinu programů napsaných v Lisp). Lisp je navíc poměrně drahý na dynamickou podporu, včetně kontroly typu za běhu a pravidelného garbage collection. V roce 1973 vznikla myšlenka vyvinout osobní počítač (pracovní stanici), navržený, počínaje hardwarem, konkrétně k dosažení co nejefektivnějšího provádění programů Lisp, včetně hardwarové podpory výpočtů lambda a dynamického psaní.
V USA, vývoj počítače Lisp se konal v 70-tých letech u Xerox korporace je Palo Alto výzkumné centrum , a u MIT (druhý sponzorovaný DARPA ). Jejich výsledkem byl vznik na počátku až polovině 80. let 20. století tří hlavních výrobců: Xerox, Lisp Machine Inc. (LMI) a Symbolics Inc. Xerox vyráběl stroje Lisp, které podporovaly Interlisp, poslední dvě společnosti pocházely z MIT a zaměřily se na Zetalisp. O něco později společnost Texas Instruments převzala výrobu strojů Lisp . V Japonsku byl v roce 1984 představen první prototyp komerčního stroje Alpha lisp společnosti Fujitsu .
Stroje Lisp měly hardwarovou architekturu zaměřenou na zpracování seznamu a funkční programování, s hardwarovou podporou pro garbage collection, dynamické psaní. Měli integrovaná vývojová prostředí obsahující tisíce funkcí a včetně všech komponent, které v současnosti tvoří IDE pro jazyk na vysoké úrovni . Podporované víceokenní grafické uživatelské rozhraní , práce s myší a dalšími doplňkovými polohovacími nástroji ( trackball , světelné pero ), vysoce kvalitní I/O grafika a zvuk. Přestože jsou orientovány na Lisp, v počítačích Lisp byly k dispozici také další jazyky na vysoké úrovni a poskytovaly prostředky pro interoperabilitu mezi jazyky. Lisp zajišťoval jak práci v interpretovaném režimu, tak kompilaci programů do objektového kódu.
Na svou dobu patřily stroje Lisp mezi nejvýkonnější počítače ve třídě osobních pracovních stanic. Předpovídala se jim velká budoucnost, ale v 90. letech se všechny přestaly používat a výrobci buď ukončili činnost, nebo se přeorientovali na výrobu univerzálních počítačů. Důvodem bylo, že v kontextu dlouhého exponenciálního růstu rychlosti a paměti počítačů se vývoj zařízení „pod jazykem“ ukázal jako marný – rychle se vyvíjející univerzální počítače vybavené překladači Lisp předběhly stroje Lisp ve svých schopností, které byly vzhledem ke své specializaci dražší a ztrácely na všestrannosti.
V SSSR se práce spojené s používáním Lisp a vytvářením vlastních Lisp systémů aktivizovaly po roce 1968, kdy skupina amerických vědců, mezi nimiž byli McCarthy a B. Berkeley[ upřesnit ] navštívil Sovětský svaz. V Novosibirsku, ve výpočetním středisku sibiřské pobočky Akademie věd, kde McCarthy strávil většinu svého času, položil základy implementace Lisp na BESM-6 . V Moskvě, ve Výpočetním centru Akademie věd SSSR, sovětští matematici Lavrov a Silagadze za pomoci Berkeleyho začali pracovat na vlastní verzi překladače Lisp pro BESM-6. Následně Lavrov šel pracovat na Leningradskou státní univerzitu a Silagadze - ve výpočetním centru Gruzínské akademie věd v Tbilisi, kde pokračoval ve spolupráci s Lisp a podílel se na vytvoření několika systémů Lisp pro počítače ES . [jedenáct]
V Leningradu vznikl systém Lisp pro polský počítač Odra 1204, v Moskvě byla vytvořena implementace pro BESM-6 kompatibilní s anglickou verzí Lisp pro počítač ICL 4, implementace pro počítač ES se objevily na MPEI a Far Východní vědecké centrum ve Vladivostoku. V Ústavu pro problémy s přenosem informací (Moskva) byl koncem 70. let minulého století vytvořen lisp systém EKLISP pro minipočítač ECLIPS. Počítače západní výroby v SSSR používaly Stanford Lisp a UT-Lisp (Dubna, IBM 370 a CDC 6600). Populární byl také švédský Nordström systém (Lisp ve Fortranu).
V roce 1975 se v Tbilisi konala čtvrtá mezinárodní konference o problémech umělé inteligence IJCAI-75, která přispěla ke zvýšení zájmu o Lisp a jeho rozšíření na univerzity a výzkumné ústavy. V roce 1978 byla vydána první učebnice Lisp v ruštině od Svyatoslava Lavrova a Givi Silagadze („Automatické zpracování dat. Jazyk LISP a jeho implementace“).
V 80. letech zájem o Lisp v SSSR pokračoval, nicméně literatury o tomto jazyce vycházelo jen velmi málo (za deset let vyšly dvě knihy, obě přeložené: "Functional Programming. Application and Implementation" od Hendersona, přeloženo v roce 1983 a dvousvazkový „Svět Lisp“ od Hyvönena a Seppänena, jehož překlad vyšel v roce 1990).
V postsovětském Rusku je použití Lisp většinou omezeno na akademický výzkum a práci jednotlivých nadšenců. Lisp se navíc na některých ruských univerzitách i nadále používá pro vzdělávací účely, ale i zde je v posledních letech znatelně vytěsněn: jako jazyk pro všeobecné použití se nevyučuje a nepoužívá a mladší studenti často preferují používat jej jako výukové jazyky pro výuku funkcionálního programování. funkcionální jazyky, které se objevily v posledních dvou desetiletích. Nicméně zájem o jazyk přetrvává, jak dokazuje vznik přeložených a původních tištěných děl na Lisp, který se obnovil v letech 2010-2020 [12] .
| Lisp | |||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Charakteristika |
| ||||||||||||||
| Implementace |
| ||||||||||||||
| Hardware |
| ||||||||||||||
| Společenství |
| ||||||||||||||
| |||||||||||||||
| Programovací jazyky | |
|---|---|
| |