Rendszer

Rendszer
Szemantika funkcionális
Nyelvóra programozási nyelv , többparadigmás programozási nyelv , funkcionális programozási nyelv , procedurális programozási nyelv és metaprogramozási nyelv [d]
A végrehajtás típusa tolmács vagy fordító
Megjelent 1975
Szerző Guy Steele és Gerald Sussman
Fájlkiterjesztés _ .scm, .ss
Kiadás
Típusrendszer erős, dinamikus
Főbb megvalósítások PLT-séma , MIT-séma , Scheme48 , Guile , JScheme
Dialektusok T
Befolyásolva Lisp , ALGOL
befolyásolta Common Lisp , JavaScript , R , Ruby , Dylan , Lua , Hop, Ütő
Weboldal schema-reports.org _ 
 Médiafájlok a Wikimedia Commons oldalon

A Scheme [ skiːm ] egy funkcionális programozási nyelv , a három legnépszerűbb Lisp dialektus egyike (a Common Lisp és Clojure mellett ). Az 1970 - es évek közepén készítette az MIT kutatói , Guy L. Steele és Gerald Jay Sussman .  

Minimalista kialakítású, minimális primitív struktúrákat tartalmaz, és lehetővé teszi, hogy mindent kifejezzen, amire szüksége van rájuk építve. Például csak két hurokmechanizmust használ – a farokrekurziót és az iteratív megközelítést (amely ideiglenes változókat használ a közbenső eredmény tárolására).

A nyelvezet Carl Hewitt színészi modelljének megvalósítására tett kísérletként indult, amelyhez Steele és Sussman "egy apró Lisp-tolmácsot" írt, majd "egy mechanizmust adtak hozzá a színészek létrehozásához és az üzenetek küldéséhez". A Scheme volt a Lisp első dialektusa, amely kizárólag statikus (nem dinamikus) változó hatókört használt , ami garantálta a farok-rekurzió optimalizálását és logikai típusú támogatást ( #tés a hagyományos és #fhelyett ). Szintén az egyik első nyelv lett, amely támogatja a folytatásokat . Az R⁵RS specifikációtól kezdve a nyelv lehetőséget kapott a szintaktikai transzformációs mintákon alapuló makrók írására „ higiénikus makróval ” . A " szemétgyűjtés " biztosított (a már nem használt objektumok memória automatikus felszabadítása). TNIL 

A nyelv listákat és egydimenziós tömböket ("vektorokat") használ alapvető adatszerkezetként. A deklarált minimalizmusnak megfelelően (még) nincs szabványos szintaxis a megnevezett mezőkkel rendelkező struktúrák támogatására, valamint az OOP lehetőségekre  - mindezt a programozó tetszés szerint megvalósíthatja, bár a legtöbb nyelvi implementáció kész mechanizmusokat kínál.

A nyelv eredeti neve, Schemer megváltozott az ITS fájlnevek hosszának korlátozása miatt ; ( angol  schemar  - "kalandor", "kombinátor"; nyilvánvalóan utalás más lisp-szerű nyelvekre, amelyek az MIT - Planner (az egyik jelentésben - "projektor") és a Conniver ("conniving ") programból jöttek ki. "). A nyelv népszerűsítéséhez jelentős mértékben hozzájárult Abelson és Sussman " A számítógépes programok szerkezete és értelmezése " című könyve , amelyet hosszú ideig a Massachusetts Institute of Technology programozási alaptankönyveként használtak.

Példák

Egyszerű matematikai műveletek:

( + 2 ( * 2 2 )) > 6 ( + 1 2 3 4 ) > 10

Az egyes műveletek (vagy függvények) meghívását egy lista képviseli, amelyben a műveletszimbólum (amely lényegében a függvény neve) mindig a kezdeti pozíciót foglalja el.

Predikátumok típusa:

( szám? 5 ) ( szám? "foo" ) ( karakterlánc? "foo" )

Megállapodás szerint minden predikátumnév -re végződik ?.

Egyenlőségi ellenőrzések:

( egyenlő? "foo" "bar" ) ( eqv? 5 ( + 2 3 )) ( eq? 'a 'A )

A makrók meghatározása a hagyományos push és pop műveletekhez:

( define-syntax push! ( syntax-rules () (( push! x l ) ( set! l ( cons x l ))))) ( define-syntax pop! ( syntax-rules () (( pop! l ) ( let (( x ( car l ))) ( set! l ( cdr l )) x ))))

Funkciódefiníciók:

;; faktoriális (nem hatékony) rekurzív stílusban ( define ( tény x ) ( if ( < x 2 ) 1 ( * ( tény ( - x 1 )) x ))) ;; Fibonacci függvény - párhuzamos rekurziót igényel ( define ( fib n ) ( cond ( ( = n 0 ) 0 ) ( ( = n 1 ) 1 ) ( else ( + ( fib ( - n 1 )) ( fib ( - n 2 )) )))) ;; a lista elemeinek összege tipikus Scheme stílusban ;; (a huroksegítő függvény egy ciklust fejez ki ;-vel; farokrekurzió és egy akkumulátor változó) ( define ( sum-list x ) ( let loop (( x x ) ( n 0 )) ( if ( null? x ) n ( ciklus ( cdr x ) ( + ( autó x ) n )))) ( 14. tény ) ( fib 10 ) ( sum-list ' ( 6 8 100 )) ( sum-list ( map fib ' ( 1 2 3 4 ))

A függvénydefiníciónak meg kell felelnie a következő prototípusnak:

( define függvénynév ( lambda ( argumentumok ) ( függvény-implementáció )))

bár a gyakorlatban gyakran használják a rövidített formát:

( define ( függvénynév argumentumok ) ( függvény-implementáció ))

I/O

A séma a porttípust használja a bemenethez és a kimenethez ( port, R5RS sec 6.6) [1] . Az R5RS két szabványos portot határoz meg, amelyek és minták állnak rendelkezésre current-input-port, amelyek current-output-portmegfelelnek a szabványos Unix I/O adatfolyamoknak . A legtöbb megvalósítás azt is biztosítja current-error-port. Az I/O átirányítást a szabvány támogatja a with-input-from-fileés eljárásokon keresztül with-output-to-file. Az implementációknak vannak string portjai is, amelyeken keresztül számos I/O művelet hajtható végre egy karakterlánc pufferen, nem pedig fájlon, az SRFI 6 eljárásaival [2] . Az R6RS szabvány bonyolultabb eljárásokat határoz meg a portok és sok új típusú port kezelésére.

A következő példák az R5RS sémában vannak írva.

( írás ( + ( olvas ) ( olvas )

Kimenet az alapértelmezett portra (current-output-port):

( let (( hello0 ( lambda () ) ( "Hello world" megjelenítése ) ( újsor )))) ( hello0 ))

Port átadása argumentumként:

( let (( hello1 ( lambda ( p ) ( "Hello world" p ) ( újsor p )))) ( hello1 ( jelenlegi kimeneti port )))

A kimenet átirányítása fájlba:

( let (( hello0 ( lambda () ) ( "Hello world" megjelenítése ) ( újsor )))) ( with-output-to-file "outputfile" hello0 ))

Egy fájl nyílt megnyitása és egy port bezárása:

( let (( hello1 ( lambda ( p ) ( "Hello world" p megjelenítése ) ( újsor p ))) ( output-port ( open-output-file "outputfile" ))) ( hello1 output-port ) ( bezárás kimenet -port kimenet-port ) )

hívás kimeneti fájllal:

( let (( hello1 ( lambda ( p ) ( "Hello world" p ) ( újsor p )))) ( call-with-output-file "outputfile" hello1 ) )

Hasonló eljárások vannak a bevitelhez. Az R5RS séma predikátumokat input-port?és output-port?. Karakterbevitelhez és -kimenethez a write-char, read-charés peek-chara char-ready?. A és eljárások a Sémakifejezések olvasására és írására readszolgálnak write. Ha a port egy olvasási művelet során elérte a fájl végét, akkor egy eof objektum kerül visszaadásra, amelyet a predikátum felismer eof-object?.

SRFI

A nyelv minimalizmusa miatt sok gyakori eljárás és szintaktikai forma nincs meghatározva a szabványban. Annak érdekében, hogy a nyelv magja kicsiben maradjon, és előmozdítsa a kiterjesztések szabványosítását, a Scheme közösség elfogadta a „Scheme Request for Implementation” folyamatot, amelynek során a javasolt kiterjesztéseket gondosan megvitatják. Ez hozzájárul a kód hordozhatóságához. Sok SRFI-t az összes vagy a legtöbb Scheme implementáció támogat.

A következő SRFI-ket [3] széles körben támogatják a megvalósítások :

  • 0: ellenőrizze a bővítményeket a következővel:cond-expand
  • 1: listák könyvtára
  • 4: homogén számvektorok
  • 6: string portok
  • 8: receive: több értékhez kötődik
  • 9: rekordtípusok
  • 13: húrok könyvtára
  • 14: karakterkészlet könyvtár
  • 16: változó aritású eljárások szintaxisa
  • 17: általánosítottset!
  • 18: többszálú támogatás
  • 19: adattípusok és eljárások az idővel való munkavégzéshez
  • 25: többdimenziós tömbök
  • 26: jelölés az eljárási argumentumok currying nélküli rögzítésére
  • 27: véletlenszerű bitek forrásai
  • 28: alapvető karakterlánc formázás
  • 29: lokalizáció
  • 30: beágyazott többsoros megjegyzések
  • 31: a rekurzív végrehajtás speciális formája
  • 37: args-fold: program argumentum processzor
  • 39: paraméterobjektumok
  • 41: adatfolyamok
  • 42: buzgó megértések
  • 43: vektoros könyvtár
  • 45: primitívek lusta iteratív algoritmusok kifejezésére
  • 60: bites műveletek
  • 61: általánosabbcond
  • 66: oktett vektorok
  • 67: összehasonlító eljárások

Főbb megvalósítások

A GNU Guile , a GNU Project kiterjesztési nyelve , egy olyan séma értelmező, amely könyvtárként van megvalósítva, és lehetővé teszi az alkalmazások számára, hogy belső sémaértelmezést hozzanak létre.

A Racket nyelv eredetileg a Scheme (eredeti nevén PLT Scheme) megvalósítása volt.

Az MIT Scheme  egy ingyenes ( GPL ) megvalósítás az x86 platformon Linux , FreeBSD , IBM OS/2 és Win32 alatt . A Chicken Scheme  egy tolmács, amely támogatja a C fordítást . A JScheme egy Java nyelven  írt tolmács ; A Kawa egy Scheme to JVM  bájtkód fordítója . A Chez Scheme fordítót már régóta kereskedelmi termékként szállítják, 2016 óta szabadon terjeszthetővé vált ( Apache ).

Összességében nagyszámú nyelvi implementáció létezik a különböző platformokhoz, különösen az ARM architektúrán alapuló mikrokontrollerekhez létezik egy Armpit Scheme interpreter [4] .

Jegyzetek

  1. ↑ Richard Kelsey; William Clinger; Jonathan Rees; Rozas, GJ; Adams IV, N. I.; Friedman, D. P.; Kohlbecker, E.; Steele Jr., G.L.; Bartley, DH Revised 5 Report on the Algorithmic Language Scheme  //  Higher-Order and Symbolic Computation : Journal. - 1998. - augusztus ( 11. évf. , 1. sz.). - 7-105 . o . - doi : 10.1023/A:1010051815785 .
  2. ↑ William D Clinger. SRFI 6: Alapvető karakterlánc-portok . The SRFI Editors, schemars.org (1999. július 1.). Letöltve: 2012. augusztus 9. Az eredetiből archiválva : 2021. október 21.
  3. ↑ SRFI-ket támogató rendszerrendszerek . The SRFI Editors, schemars.org (2009. augusztus 30.). Letöltve: 2012. augusztus 9. Az eredetiből archiválva : 2021. június 20.
  4. ↑ Séma értelmező ARM mikrokontrollerekhez . Hozzáférés dátuma: 2014. december 30. Az eredetiből archiválva : 2014. december 30.

Irodalom

Linkek

 Programozási nyelvek