Schema

Schema
Semantik funktionell
Språkklass programmeringsspråk , programmeringsspråk med flera paradigm , funktionellt programmeringsspråk , procedurspråk och metaprogrammeringsspråk [d]
Utförandetyp tolk eller kompilator
Framträdde i 1975
Författare Guy Steele och Gerald Sussman
Filtillägg _ .scm, .ss
Släpp
Typ system stark, dynamisk
Stora implementeringar PLT Scheme , MIT Scheme , Scheme48 , Guile , JScheme
Dialekter T
Blivit påverkad Lisp , ALGOL
påverkas Common Lisp , JavaScript , R , Ruby , Dylan , Lua , Hop, Racket
Hemsida scheme-reports.org _ 
 Mediafiler på Wikimedia Commons

Scheme [ skiːm ] är ett funktionellt programmeringsspråk , en av de tre mest populära Lisp- dialekterna (tillsammans med Common Lisp och Clojure ). Skapad i mitten av 1970 - talet av MIT - forskarna Guy L. Steele och Gerald Jay Sussman .  

Den har en minimalistisk design, innehåller ett minimum av primitiva strukturer och låter dig uttrycka allt du behöver genom att bygga ovanpå dem. Till exempel använder den bara två looping-mekanismer - svansrekursion och en iterativ metod (som använder temporära variabler för att lagra ett mellanresultat).

Språket började som ett försök att implementera Carl Hewitts skådespelaremodell , för vilken Steele och Sussman skrev "en liten Lisp-tolkare" och sedan "tillade en mekanism för att skapa skådespelare och skicka meddelanden." Scheme var den första dialekten av Lisp som uteslutande använde statisk (snarare än dynamisk) variabel omfattning , vilket garanterade optimering av svansrekursion och gav stöd för boolesk typ ( #toch #fistället för traditionella Toch NIL). Blev också ett av de första språken som stödde fortsättningar . Från och med R⁵RS-specifikationen fick språket en möjlighet att skriva makron baserade på syntaktiska transformationsmönster med " hygieniskt makro " .  " Sopsamling " tillhandahålls (automatisk frigöring av minne från objekt som inte längre används).

Språket använder listor och endimensionella arrayer ("vektorer") som grundläggande datastrukturer. I enlighet med den deklarerade minimalismen finns det (ännu) ingen standardsyntax för att stödja strukturer med namngivna fält, såväl som OOP- faciliteter  - allt detta kan implementeras av programmeraren efter hans önskemål, även om de flesta språkimplementeringar erbjuder färdiga mekanismer.

Det ursprungliga namnet på språket, Schemer, ändrades på grund av begränsningen av längden på filnamn i ITS ; ( Engelska  schematare  - "äventyrare", "kombinator"; tydligen en antydan om andra lispliknande språk som kom ur MIT - Planner (i en av betydelserna - "projektor") och Conniver (" conniving" "). Ett betydande bidrag till populariseringen av språket gjordes av boken " The Structure and Interpretation of Computer Programs " av Abelson och Sussman , som under lång tid användes som en grundläggande programmeringslärobok vid Massachusetts Institute of Technology.

Exempel

Enkla matematiska operationer:

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

Anropet till varje operation (eller funktion) representeras av en lista där operationssymbolen (som i huvudsak är namnet på funktionen) alltid upptar den initiala positionen.

Typ predikat:

( nummer? 5 ) ( nummer? "foo" ) ( sträng? "foo" )

Enligt konvention slutar alla predikatnamn med ?.

Jämställdhetskontroller:

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

Definition av makron för traditionella push- och popoperationer:

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

Funktionsdefinitioner:

;; faktoriell i (ineffektiv) rekursiv stil ( definiera ( fakta x ) ( if ( < x 2 ) 1 ( * ( fakta ( - x 1 )) x ))) ;; Fibonacci-funktion - kräver parallell rekursion ( definiera ( fib n ) ( cond (( = n 0 ) 0 ) (( = n 1 ) 1 ) ( else ( + ( fib ( - n 1 )) ( fib ( - n 2 )) )))) ;; summan av elementen i listan i en typisk Scheme-stil ;; (loophjälparfunktionen uttrycker en loop med ;; svansrekursion och en ackumulatorvariabel) ( define ( summa-list x ) ( let loop (( x x ) ( n 0 )) ( if ( null? x ) n ( loop ( cdr x ) ( + ( bil x ) n ))))) ( fakta 14 ) ( fib 10 ) ( summalista ' ( 6 8 100 )) ( summalista ( kartfib ' ( 1 2 3 4 ) ))

Funktionsdefinitionen måste överensstämma med följande prototyp:

( definiera funktionsnamn ( lambda ( argument ) ( funktionsimplementering )))

även om i praktiken ofta den förkortade formen används:

( definiera ( funktionsnamnargument ) ( funktionsimplementering ) )

I/O

Schema använder porttypen för ingång och utgång ( port, R5RS sec 6.6) [1] . R5RS definierar två standardportar, tillgängliga som current-input-portoch current-output-port, motsvarande standard Unix I/O-strömmar . De flesta implementeringar ger också current-error-port. I/O-omdirigering stöds i standarden genom procedurerna with-input-from-fileoch with-output-to-file. Implementeringar har också strängportar genom vilka många I/O-operationer kan utföras på en strängbuffert istället för en fil, med hjälp av procedurer från SRFI 6 [2] . R6RS-standarden definierar mer komplexa procedurer för att hantera portar och många nya typer av portar.

Följande exempel är skrivna i R5RS Scheme.

( skriv ( + ( läs ) ( läs )))

Utdata till standardporten (strömutmatningsport):

( let (( hello0 ( lambda () ( visa "Hello world" ) ( newline )))) ( hello0 ))

Att skicka en port som argument:

( let (( hello1 ( lambda ( p ) ( visa "Hello world" p ) ( newline p )))) ( hello1 ( aktuell-utgång-port )))

Omdirigerar utdata till en fil:

( let (( hello0 ( lambda () ( visa "Hello world" ) ( newline )))) ( with-output-to-file "outputfile" hello0 ))

Explicit öppna en fil och stänga en port:

( let (( hello1 ( lambda ( p ) ( visa "Hello world" p ) ( newline p ))) ( output-port ( open-output-fil "outputfile" ))) ( hello1 output-port ) ( close-output -port output-port ) )

call-with-output-fil:

( låt (( hej1 ( lambda ( p ) ( visa "Hello world" p ) ( nyrad p )))) ( ring-med-utgångsfil "utgångsfil" hej1 ))

Det finns liknande procedurer för inmatning. R5RS Scheme tillhandahåller predikat input-port?och output-port?. För teckeninmatning och -utmatning finns write-char, read-char, peek-charoch char-ready?. Procedurerna och används för att läsa och skriva readschemauttryck write. Om porten har nått slutet av filen vid en läsoperation, returneras ett eof-objekt som kan kännas igen av predikatet eof-object?.

SRFI

På grund av språkets minimalism är många vanliga procedurer och syntaktiska former inte definierade i standarden. För att hålla kärnan i språket liten och för att främja standardisering av tillägg, har Scheme-gemenskapen antagit en "Scheme Request for Implementation"-process genom vilken föreslagna tillägg diskuteras noggrant. Detta bidrar till kodens portabilitet. Många SRFI:er stöds av alla eller de flesta Scheme-implementeringar.

Följande SRFI:er [3] stöds brett av implementeringar :

  • 0: kontrollera för tillägg medcond-expand
  • 1: bibliotek för listor
  • 4: homogena talvektorer
  • 6: strängportar
  • 8: receive: bind till flera värden
  • 9: skivtyper
  • 13: bibliotek för stråkar
  • 14: teckenuppsättningsbibliotek
  • 16: syntax för variabla aritetsprocedurer
  • 17: generaliseradset!
  • 18: stöd för flera trådar
  • 19: datatyper och procedurer för att arbeta med tid
  • 25: flerdimensionella arrayer
  • 26: notation för att fixa procedurargument utan att krångla
  • 27: källor till slumpmässiga bitar
  • 28: grundläggande strängformatering
  • 29: lokalisering
  • 30: kapslade flerradskommentarer
  • 31: en speciell form av rekursiv avrättning
  • 37: args-fold: programargumentprocessor
  • 39: parameterobjekt
  • 41: dataströmmar
  • 42: ivriga uppfattningar
  • 43: vektorbibliotek
  • 45: primitiver för att uttrycka lata iterativa algoritmer
  • 60: bitoperationer
  • 61: mer allmäntcond
  • 66: oktettvektorer
  • 67: jämförelseförfaranden

Stora implementeringar

GNU Guile , förlängningsspråket för GNU-projektet , är en Scheme-tolk implementerad som ett bibliotek som tillåter applikationer att skapa en intern Scheme-tolk.

Racket - språket var ursprungligen en implementering av Scheme (ursprungligen kallat PLT Scheme).

MIT Scheme  är en gratis ( GPL ) implementering för x86 -plattformen under Linux , FreeBSD , IBM OS/2 och Win32 . Chicken Scheme  är en tolk som stöder C -översättning . JScheme  är en tolk skriven i Java ; Kawa är en Scheme to JVM  bytecode kompilator . Chez Scheme- kompilatorn har levererats som en kommersiell produkt under lång tid, sedan 2016 har den distribuerats fritt ( Apache ).

Totalt finns det ett stort antal språkimplementeringar för olika plattformar, i synnerhet finns det en Armpit Scheme-tolk för mikrokontroller baserad på ARM-arkitekturen [4] .

Anteckningar

  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. - Augusti ( vol. 11 , nr 1 ). - S. 7-105 . - doi : 10.1023/A:1010051815785 .
  2. ↑ William D Clinger. SRFI 6: Grundläggande strängportar . SRFI Editors, schemers.org (1 juli 1999). Hämtad 9 augusti 2012. Arkiverad från originalet 21 oktober 2021.
  3. ↑ Schema Systems Supporting SRFIs . SRFI Editors, schemers.org (30 augusti 2009). Hämtad 9 augusti 2012. Arkiverad från originalet 20 juni 2021.
  4. ↑ En schematolk för ARM-mikrokontroller . Datum för åtkomst: 30 december 2014. Arkiverad från originalet 30 december 2014.

Litteratur

Länkar

 Programmeringsspråk