| Systém | |
|---|---|
| Sémantika | funkční |
| Jazyková třída | programovací jazyk , multiparadigmatický programovací jazyk , funkcionální programovací jazyk , procedurální programovací jazyk a metaprogramovací jazyk [d] |
| Typ provedení | interpret nebo kompilátor |
| Objevil se v | 1975 |
| Autor | Guy Steele a Gerald Sussman |
| Přípona souboru | .scm, .ss |
| Uvolnění |
|
| Typový systém | silný, dynamický |
| Hlavní implementace | Schéma PLT , schéma MIT , schéma48 , Guile , JScheme |
| Dialekty | T |
| Byl ovlivněn | Lisp , ALGOL |
| ovlivnil | Common Lisp , JavaScript , R , Ruby , Dylan , Lua , Hop, Raketa |
| webová stránka | schéma-reports.org _ |
| Mediální soubory na Wikimedia Commons | |
Scheme [ skiːm ] je funkcionální programovací jazyk , jeden ze tří nejoblíbenějších dialektů Lisp (spolu s Common Lisp a Clojure ). Vytvořeno v polovině 70. let výzkumníky MIT Guyem L. Steelem a Geraldem Jayem Sussmanem .
Má minimalistický design, obsahuje minimum primitivních struktur a umožňuje vám vyjádřit vše potřebné tím, že na ně postavíte. Například používá pouze dva mechanismy cyklování – koncovou rekurzi a iterativní přístup (který používá dočasné proměnné k uložení mezivýsledku).
Jazyk začal jako pokus implementovat herecký model Carla Hewitta , pro který Steele a Sussman napsali „malého tlumočníka Lisp“ a poté „přidali mechanismus pro vytváření herců a odesílání zpráv“. Scheme byl prvním dialektem jazyka Lisp, který používal výhradně statický (spíše než dynamický) proměnný rozsah , který zaručoval optimalizaci ocasu-rekurze a poskytoval podporu typu boolean ( #ta #fmísto tradičního Ta NIL). Stal se také jedním z prvních jazyků, které podporovaly pokračování . Počínaje specifikací R⁵RS získal jazyk schopnost psát makra založená na syntaktických transformačních vzorcích s „ hygienickým makrem “ . Je poskytován „ garbage collection “ (automatické uvolnění paměti z objektů, které se již nepoužívají).
Jazyk používá seznamy a jednorozměrná pole ("vektory") jako základní datové struktury. V souladu s deklarovaným minimalismem (zatím) neexistuje žádná standardní syntaxe pro podpůrné struktury s pojmenovanými poli, stejně jako OOP zařízení - to vše může programátor implementovat podle své preference, ačkoli většina jazykových implementací nabízí hotové mechanismy.
Původní název jazyka, Schemer, byl změněn kvůli omezení délky názvů souborů v ITS ; ( Anglický plánovač - "dobrodruh", "kombinátor"; zjevně náznak jiných jazyků podobných lispu, které vyšly z MIT - Planner (v jednom z významů - "projektor") a Conniver (" conniving "). K popularizaci jazyka významně přispěla kniha „ The Structure and Interpretation of Computer Programs “ od Abelsona a Sussmana , která byla dlouhou dobu používána jako základní učebnice programování na Massachusetts Institute of Technology.
Jednoduché matematické operace:
( + 2 ( * 2 2 )) > 6 ( + 1 2 3 4 ) > 10Volání každé operace (nebo funkce) je reprezentováno seznamem, ve kterém symbol operace (což je v podstatě název funkce) vždy zaujímá počáteční pozici.
Typové predikáty:
( číslo? 5 ) ( číslo? "foo" ) ( string? "foo" )Podle konvence končí všechna jména predikátů? na .
Kontroly rovnosti:
( rovná se? "foo" "bar" ) ( ekv ? 5 ( + 2 3 )) ( rov.? 'a 'A )Definice maker pro tradiční operace push a pop:
( definovat-syntaxe push! ( syntax-rules () (( push! x l ) ( set! l ( cons x l ))))) ( definujte-syntax pop! ( syntax-rules () (( pop! l ) ( let (( x ( auto l ))) ( set! l ( cdr l )) x ))))Definice funkcí:
;; faktoriál v (neefektivním) rekurzivním stylu ( definuj ( fakt x ) ( if ( < x 2 ) 1 ( * ( fakt ( - x 1 )) x ))) ;; Fibonacciho funkce – vyžaduje paralelní rekurzi ( definujte ( fib n ) ( cond ( ( = n 0 ) 0 ) ( ( = n 1 ) 1 ) ( else ( + ( fib ( - n 1 )) ( fib ( - n 2 )) )))) ;; součet prvků seznamu v typickém stylu Scheme ;; (pomocná funkce smyčky vyjadřuje smyčku s ;; koncovou rekurzi a akumulační proměnnou) ( definovat ( sum-list x ) ( nechat smyčku (( x x ) ( n 0 )) ( if ( null? x ) n ( smyčka ( cdr x ) ( + ( auto x ) n ))))) ( fact 14 ) ( fib 10 ) ( sum-list ' ( 6 8 100 )) ( sum-list ( map fib ' ( 1 2 3 4 )))Definice funkce musí odpovídat následujícímu prototypu:
( definujte název-funkce ( lambda ( argumenty ) ( implementace funkce )))i když v praxi se často používá zkrácená forma:
( definovat ( argumenty názvu funkce ) ( implementace funkce ))Schéma používá typ portu pro vstup a výstup ( port, R5RS sec 6.6) [1] . R5RS definuje dva standardní porty dostupné jako current-input-porta current-output-port, které odpovídají standardním unixovým I/O streamům . Většina implementací také poskytuje current-error-port. Přesměrování I/O je standardem podporováno prostřednictvím procedur with-input-from-filea with-output-to-file. Implementace mají také řetězcové porty, přes které lze provádět mnoho I/O operací v řetězcové vyrovnávací paměti namísto souboru, pomocí procedur ze SRFI 6 [2] . Standard R6RS definuje složitější postupy pro práci s porty a mnoho nových typů portů.
Následující příklady jsou zapsány ve schématu R5RS.
( psát ( + ( číst ) ( číst )))Výstup na výchozí port (aktuální-výstupní-port):
( let (( hello0 ( lambda () ( display "Ahoj světe" ) ( nový řádek )))) ( hello0 ))Předání portu jako argument:
( let (( hello1 ( lambda ( p ) ( display " Hello world" p ) ( newline p )))) ( hello1 ( current-output-port )))Přesměrování výstupu do souboru:
( let (( hello0 ( lambda () ( display "Ahoj světe" ) ( nový řádek )))) ( with-output-to-file "outputfile" hello0 ))Explicitní otevření souboru a uzavření portu:
( let (( hello1 ( lambda ( p ) ( display "Ahoj svět" p ) ( nový řádek p ))) ( output-port ( open-output-file "outputfile" ))) ( hello1 output-port ) ( close-output -výstup portu-port ) )call-with-output-file:
( let (( hello1 ( lambda ( p ) ( display "Ahoj světe" p ) ( nový řádek p )))) ( call-with-output-file "outputfile" hello1 ))Pro zadávání existují podobné postupy. Schéma R5RS poskytuje predikáty input-port?a output-port?. Pro vstup a výstup znaků existují write-char, read-char, peek-chara char-ready?. Procedury a se používají ke čtení a zápisu readvýrazů schématu write. Pokud port při operaci čtení dosáhl konce souboru, vrátí se objekt eof, který lze rozpoznat predikátem eof-object?.
Vzhledem k minimalismu jazyka není ve standardu definováno mnoho běžných postupů a syntaktických forem. Aby bylo jádro jazyka malé a aby se podpořila standardizace rozšíření, komunita Scheme přijala proces „Scheme Request for Implementation“, v jehož rámci jsou pečlivě diskutována navrhovaná rozšíření. To přispívá k přenositelnosti kódu. Mnoho SRFI je podporováno všemi nebo většinou implementací schématu.
Následující SRFI [3] jsou široce podporovány implementacemi :
GNU Guile , rozšiřující jazyk projektu GNU , je interpret schémat implementovaný jako knihovna, která umožňuje aplikacím vytvářet interní interpret schémat.
Jazyk Racket byl původně implementací Scheme (původně nazývaného PLT Scheme).
MIT Scheme je bezplatná implementace ( GPL ) pro platformu x86 pod Linuxem , FreeBSD , IBM OS/2 a Win32 . Chicken Scheme je tlumočník, který podporuje překlad C. JScheme je interpret napsaný v Javě ; Kawa je kompilátor bajtového kódu schématu JVM . Překladač Chez Scheme je dlouhodobě dodáván jako komerční produkt, od roku 2016 je volně distribuován ( Apache ).
Celkem existuje velké množství jazykových implementací pro různé platformy, konkrétně existuje interpret Armpit Scheme pro mikrokontroléry založený na architektuře ARM [4] .
| Lisp | |||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Charakteristika |
| ||||||||||||||
| Implementace |
| ||||||||||||||
| Hardware |
| ||||||||||||||
| Společenství |
| ||||||||||||||
| |||||||||||||||
| Programovací jazyky | |
|---|---|
| |