Despre schema de limbaj de programare

Despre limbajul de programare Scheme

0. O intrare mică.

Această notă este dedicată limbaj de programare (PL) Schema.

Schema ca multiparadigm LISP este un limbaj de programare „aproape nici o sintaxă“, dezvoltat în Massachusetts Institute of Technology. Unii numesc limbajul de programare Schema de funcționale (FP), astfel echivalând într-o limbă pur funcțională în asemănarea Haskell, cu toate acestea, în ciuda faptului că sistemul vă permite să scrie cod în stilul PC-ul, este echivalând corect. O descriere mai precisă și detaliată a limbii puteți găsi pe Wikipedia, acolo și pentru a găsi unele link-uri mai utile.

Așa cum înainte de a scrie acest articol am lăsat câteva dintre acestea pe câteva forumuri de pe net, acest lucru, în primul rând, o notă pe acest blog va fi relativ mai mult decât următorul și constau din notele de mai sus pe forumuri.

1. Câteva cuvinte despre „aproape nici o sintaxă“.

Spre deosebire de mai frecvente și familiar PL, cum ar fi C, C ++, Pascal, Java, PHP, și așa mai departe. D. în Schema și Lisp utilizează funcțiile de înregistrare prefix și operatori, precum și un număr foarte mare de paranteze, care ar putea descuraja nou-veniți de la învățarea limbii, dar mai departe te duci în studiu al sistemului, cu atât mai mult vă va da seama că aceasta este o formă foarte convenabil de a scrie, care se deschide mari oportunități pentru manipularea codului și a datelor. Dar nu exclud efectul de respingere în continuare =). În acest caz, uita-te la Forth, în cazul în care acesta este utilizat polonez, notația postfix, se va părea și mai neobișnuit și respingătoare =).

Deci, aici sunt câteva exemple în programe Schema de:

(* 1 2 3 4 5); Produsul din numerele de la 1 la 5

După cum puteți vedea, sintaxa este într-adevăr regulate și aproape nu sunt disponibile, orice apel funcție are următoarea formă:

(Funcname arg1 arg2 Arg3. ArgN)

numita S-exprimare. Limitele formularului sunt paranteze și numele delimitate - spațiu gol (spațiu, tab și newline). Primul caracter este interpretat ca un apel de funcție asociată cu ea pentru restul valorilor calculate asociate acestora, cu ea indiferent de ceea ce este valoarea - funcția sau, de exemplu, o constantă numerică, astfel încât transferul de funcții ca parametri pentru alte funcții este simplă și nu strica sintaxa, de exemplu:

2. Un pic despre liste.

Structura de date de bază în cadrul sistemului, ca în Lisp, o listă. Principalele funcții de lucru cu liste:

(Contra 1 din 2); returnează perechea valoare: (1. 2)
(Contra 1 # 039 ()); returnează o listă cu un singur element (1)
(Lista 1 2 3); Returnează o listă de valori: (1 2 3)
(Contra 1 (contra 2 (cons 3 # 039 ()))); returnează o listă de valori: (1 2 3)
(Car (lista 1 2 3)); returnează o valoare a primului element (cap) Lista (1 2 3): 1
(Cdr (lista 1 2 3)); Se returnează o listă care începe cu al doilea element (coada) Lista (1 2 3): (2 3)

desen # 039 () reprezintă o listă goală, simbolul # 039 reprezintă referința bibliografică este de zahăr sintactic pentru formele de singular (citat.). De exemplu, apelul funcției

(Lista 1 2 3); poate fi înlocuit cu un design:
# 039 (1 2 3)

Cu toate acestea, ele nu trebuie confundate cu privire la tipul de numere, valori constante, numere, siruri de caractere închise în ghilimele duble, cele două expresii sunt egale, dar în raport cu simbolurile asociate cu orice valoare, da rezultate diferite, cum ar fi:

(Fie ((x 1), (y 2) (z 3)); Fie x = 1, y = 2, z = 3, atunci:
(List x y z)); va returna o listă de variabile x, y și z: (1 2 3)
(Fie ((x 1), (y 2) (z 3))
# 039 (x y z)); va returna o listă de simboluri x y și z: (x y z)

3. macro-uri.

Macrocomenzile vă permit să creați o nouă formă specială, extinzându-se astfel sintaxa limbii. De exemplu:

(Definiți-sintaxa mea în cazul în care; Declararea sintaxa numelui
(Sintaxa reguli (atunci altceva); descriu regulile: prima listă - (apoi altceva) -
; Enumerăm cuvintele care nu sunt calculate, a la „cuvinte rezervate“
; în lista de mai jos descrie șabloanele care va procesa macro
; si stivuitoare proprii:

((_ Starea apoi la-adevărat altceva pe-false), aici descrie un model de design: _ - aici numele macro substituit,
; puteți scrie-mi în cazul în care în loc de _. nici o diferență
; atunci și altceva, așa cum am descris anterior doar un cuvânt,
; condiție, pe-adevărat și pe fals - ca să spunem așa variabilele locale într-un macro,
; expresii transferate acestora - sunt calculate
(În cazul în care starea pe true la-fals)); și acest handler șablon. Șabloanele pot fi mai mult, de exemplu, puteți adăuga un alt 2:
((_ Stare apoi on-true)
(În cazul în care starea la-true))
((_ Stare altceva pe-false)
(În cazul în care (nu condiție) la fals))
)); liste de aici apropiate forme specifice de sintaxa reguli și defini-sintaxă.

; Acum putem folosi macro inventat:
(My-if (> 02 aprilie), apoi (afișare "Y \ n") altceva (afișare "N \ n"))
(My-if (> 02 aprilie), apoi (afișare "Y \ n"))
(My-if (> 02 aprilie) altceva (afișare "Y \ n"))

Utilizați doar definiția funcției nu ar fi fost aici, deoarece valorile argumentele functiei sunt evaluate înainte de a fi transmise la funcția t. E. Vom, în orice caz, programul va fi luată de către operatorul ambelor ramuri, indiferent de valoarea argumentului-condiții și pentru a evita acest lucru, a trebuit să pentru fiecare dată în mod explicit de trecere funcție cu argumente ramuri (întârziere.). Am salva calculul argumentului său.

Un alt exemplu care arată punerea în aplicare a operatorilor i ++, Eu--, x + = y, x - = y, x * = y și x / = y, conținând inclusiv elemente de meta-programare: macro make-op în sine creează macro-uri pentru noi determinarea ultimii patru operatori:

(Definiți-sintaxa face
(Sintaxa reguli ()
((_ FUNC Op)
(Definiți-sintaxa op
(Sintaxa reguli ()
((_ X y)
(Începe (set! X (FUNC x y)) x)))))))

(Definirea-sintaxa ++
(Sintaxa reguli ()
((_ I)
(Începe (set! I (+ i 1)) i))))

(Definiți-sintaxa -
(Sintaxa reguli ()
((_ I)
(Începe (Set I (-! I 1)) i))))

(Definiți x1 2)
(Definiți x2 3)
(Message "x1 =" x1 "x2 =" x2)
(++ x1)
(+ = X2 (- x2))
(Message "x1 =" x1 "x2 =" x2)
(+ = X1 x2) (mesajul "x1 =" x1)
(* = X1 x2) (mesajul "x1 =" x1)
(- = x1 x2) (mesajul "x1 =" x1)
(/ = X1 x2) (mesajul "x1 =" x1)

4. curtau, închideri și funcții de ordin superior.

Acum, primerchik cu curtau (aducerea funcției de n argumente pentru o funcție de un argument, returnează o funcție de n-1 argumente) și funcții de ordin superior (funcții care operează pe alte funcții):

(Definiți (make-Val-lista v0 DV vN)
(Definiți (make-lista v)
(If (= v vN)
(Contra v # 039 ())
(V Cons (make-lista (+ v dv)))))
(Asigurați-lista v0))

(Definirea A-list (make-val-list 1 1 3))
(Definiți x-list (make-val-list 0.2 0.1 1.2))

(Definiți (y A)
(Lambda (x) (- (* A x) (tan (* pi (/ x 4))))))

(Definiți y-lista (hartă (lambda (A)
(Map (y A) x-list))
A-list))

(Arată hartă ((lambda (ls) (se aplică ls max)) y-list))

În acest cod, funcția (x, A) se reduce la functia y (A), o restabilirea functiei-de (x), adică poate fi aplicată după cum urmează:

(Fie ((A1 1) (x1 0.2))
((Y A1) x1))

Curtau foarte similar cu circuitul așa cum înțeleg eu, numai vina este prezentată în următoarele etape:

(Definirea y1 (y 1)); crea funcția (y1 x) = (- (* 1 x) (tan (* pi (/ x 4))))
(Definirea y2 (y 2)); crea funcția (y1 x) = (- (* 2 x) (tan (* pi (/ x 4))))
(X1 Y1)
(X1 Y2)

În exemplul utilizat de ordin superior funcțiilor hartă și aplica, funcționează după cum urmează:

1) harta transmisă pe care o aplică în funcție de argumentul trecut la fiecare element din lista transmisă de al doilea argument, și returnează o listă de valori rezultattov aplicare, de exemplu

(Definiți test listă # 039 (-2 1 7 0 -5 4))
(Map abs test listă); va returna o listă a valorilor absolute ale testului lista LOV: (2 1 7 0 5 4)

2) se aplică aplică trecut la ea ca primul argument la elementele listei transmise de al doilea argument,
ca ei Bud (lista articole) sunt parametri funcții transferate, astfel de funcții

(Max -2 1 7 0 4 -5); \
(+ -2 1 7 0 -5 4); Valoarea maximă a _vernut și suma valorilor transmise ca parametri, respectiv.

ci o încercare de a le provoca astfel:

(Test lista Max). \
(+ Test-list); Eroare _vydast.

Acest lucru nu este foarte util atunci când, de exemplu, în cadrul programului a generat o listă de valori din care apoi au nevoie pentru a selecta valoarea maximă sau suma numărului. Și apoi vine în ajutorul aplica funcție care arată modul în care-a lista, adică. E. Exprimarea

(Aplicare max test lista); \
(Aplicare + test lista); expresii _ekvivalentny
(Max -2 1 7 0 4 -5); \
(+ -2 1 7 0 -5 4); _sootvetstvenno.

Și, în cele din urmă du-te înapoi la curtau. După cum se poate observa din descrierea funcției de hartă, aceasta poate funcționa numai funcții de o variabilă. A fost apoi până la noi și să vină la ajutorul = curtau și închiderea).

5. Un pic despre funcțiile și macro-uri cu un număr arbitrar de argumente.

După cum probabil ați observat, unele dintre funcțiile și formele pot lua orice număr de argumente, cum ar fi:

(+ 1 2 3)
(+ 1 2 3 4)
(Și exp1 exp2)
(Și exp1 exp2 exp3 exp4)

Pentru a crea o astfel de funcție, trebuie să utilizați punct de înregistrare argumente, de exemplu:

(Definiți (mesaj de cap. Coada)
(Cap de afișare)
(Pentru fiecare coadă-display)
(Newline))

În această definiție a funcției primul argument va fi transmis direct, capul parametru, și toate celelalte - lista coada. Acesta utilizează o altă funcție de ordin superior pentru fiecare-, care se aplică funcția transmisă ca primul argument pentru fiecare element al listei transmise de al doilea argument, dar în contrast cu funcția de hartă nu returnează o valoare. Acum puteți utiliza funcția de mesaj:

(Mesaj "Hello World!")
(Fie ((World "World"))
(Mesaj "Bună ziua" lume "!"))

Se determină forma care ia orice număr de argumente, este posibil în acest fel:

(Definirea-sintaxa și
(Sintaxa reguli ()
((_) #t)
((_ E) e)
((_ E1 e2 e3.)
(Dacă e1 (și e3 e2.) #F))))

Apoi, puteți utiliza noua formă, după cum urmează:

Asta încheie comentariul meu. Sper că a fost / ar fi util pentru cineva pentru cineva interesant. =)