Mintegy programozási nyelv rendszere

A rendszer programozási nyelv

0. Egy kis bejegyzést.

Ez a megjegyzés fordítják programozási nyelv (PL) rendszer.

Rendszernek a többparadigmás Lisp programozási nyelv „szinte nincs szintaktikai” alakult ki a Massachusetts Institute of Technology. Egyesek a rendszer nyelvét funkcionális programozás (FP), így egyenlővé, hogy tisztán funkcionális nyelv a hasonlóság a Haskell azonban annak ellenére, hogy a rendszer lehetővé teszi, hogy írjon kódot a PC stílusban, egyenlőségjelet helyesen. A pontosabb és részletesebb leírást a nyelv megtalálható a Wikipedia, és ott talál néhány hasznos linkeket.

Mint korábban írásban ezt a cikket hagytam egy pár ilyen egy pár fórumok a neten, ez egyrészt egy megjegyzés a blogon lesz viszonylag hosszabb, mint a következő, és tartalmazza a fenti megjegyzéseket a fórumokon.

1. Néhány szó a „szinte nincs szintaxis”.

Ellentétben a több közös és jól PL, mint a C, C ++, Pascal, Java, PHP, és így tovább. D. program és a Lisp használ előtag felvételi funkciók és szereplők, valamint a nagyszámú zárójelben, amelyek megakadályozzák érkezettek nyelvtanulás, de a további bemegy a tanulmány a rendszer, annál több lesz észre, hogy ez egy nagyon kényelmes formája az írás, amely megnyitja nagy lehetőségeket nyújt a manipuláció kód és az adatok. De nem zárják ki a hatását tovább elutasítás =). Ebben az esetben nézd meg a Forth, ahol alkalmazzák a lengyel, postfix jelölés, akkor úgy tűnik, még szokatlan és visszataszító =).

Tehát itt van néhány példa a rendszer programok:

(* 1 2 3 4 5); A termék a számok 1-től 5

Mint látható, a szintaxis valóban rendszeres és szinte nem áll rendelkezésre, bármilyen függvényhívás a következő formában:

(Funcname arg1 arg2 arg3. Argn)

az úgynevezett S-expresszió. A határait a forma a zárójelben, és behatárolt nevek - üres tér (szóköz, tab és új sor). Az első karakter értelmezi a függvényhívás társítva a többi számított érték velük kapcsolatban, és nem számít, mi az értéke - a funkció, vagy például egy numerikus konstans, így a feladatok átadását paraméterként egyéb funkciók egyszerű és nem rontja szintaxis, például:

2. Egy kicsit listákat.

Az alapvető adatstruktúra reakcióvázlat, mint a Lisp, egy lista. A fő funkciók dolgozó jelent meg:

(Cons 1 2); visszaadja az érték pár: (1 2)
(Cons 1 # 039 ()); visszaadja a lista egy elem (1)
(Lista 1 2 3); Visszaadja értékek listája: (1 2 3)
(Cons 1 (cons 2 (cons 3 # 039 ()))); listáját adja vissza értékek: (1 2 3)
(Car (1-lista-2 3)); értéket ad vissza az első elem (fej) lista (1 2 3): 1
(CDR (1-lista-2 3)); Ez egy listát ad vissza, kezdve a második elem (a farok) lista (1 2 3) (2 3)

tervezés # 039 () jelöli egy üres listát, akkor a szimbólum # 039 képviseli a idézet szintaktikus cukor egyes számú formák (idézet.). Például a függvényhívás

(Lista 1 2 3); helyettesíteni lehet design:
039 # (1 2 3)

Ezek azonban nem szabad összekeverni, tekintettel a típusú számok, állandók értékeit, számok, húrok idézőjelbe, a két kifejezés egyenlő, de kapcsolatban a szimbólumok kapcsolódó bármilyen értéket, eltérő eredményeket, mint például:

(Legyen ((x 1) (Y 2) (Z 3)); Legyen x = 1, y = 2, Z = 3, akkor:
(List X Y Z)); visszatér egy listát a változók x, y és z: (1 2 3)
(Legyen ((x 1) (Y 2) (Z 3))
# 039 (x y z)); visszatér egy listát a szimbólumok x y és z: (x y z)

3. makrók.

A makrók lehetővé teszi, hogy hozzon létre egy új, speciális forma, ezzel kiterjesztve a szintaxis a nyelvet. Például:

(Adjuk-mondattani én-ha; állapítsa neve szintaxis
(Szintaxis szabályai (akkor még) leírja a szabályokat: az első listát - (akkor még) -
; Felsoroljuk a szavakat, amelyek nem számítjuk, a la „fenntartott szó”
; Az alábbi lista a sablonokat, hogy feldolgozza a makro
; és a megfelelő rakodók:

((_ Állapot majd on-true else on-false); itt írja le a mintázata: _ - itt helyettesített makró nevét,
; írhat az én-ha ahelyett, _. nincs különbség
; és akkor mást már leírtuk csak egy szó,
; állapotban, on-igaz és a hamis-- úgymond helyi változók makró
; kifejezések át őket - számítjuk
(Ha a feltétel igaz, on-on-hamis)); és ezt a sablont felvezető. Sablonok lehet több, például, akkor újabb 2:
((_ Állapot majd on-igaz)
(Ha a feltétel on-true))
((_ Állapota mást-hamis)
(Ha (nem feltétel) on-hamis))
)); Itt közel felsorolja azokat a különleges formákat szintaktikai szabályok és meghatározza-szintaxis.

; Most már tudjuk használni feltalált makró:
(My-ha (>: április 2.), majd (kijelzőn "Y \ n") else (kijelzőn "N \ n"))
(My-ha (>: április 2.), majd (kijelzőn "Y \ n"))
(My-if (> 2 április) más (display "Y \ n"))

Használja csak a függvény definíciójában nem lett volna itt, mert a függvény értékei érveit értékelik, mielőtt továbbítjuk a funkció t. E. Azt minden esetben a program kellene venni az üzemeltető által két ága, értékétől függetlenül az érvelés-körülmények között, és elkerülni, azt kellett hogy minden egyes alkalommal kifejezetten átmenő függvényargumentumok ágak (késleltetés.). Azt menteni a számítás az érvelését.

Egy másik példa mutatja a végrehajtás a szolgáltatók i ++, én--, x + = y, x - = y, x * = y és x / = y, amely többek között elemeit meta-programozás: makro make-op maga teremti makrók számunkra meghatározó az elmúlt négy szereplők:

(Adjuk-szintaxis Márka
(Szintaxis szabályai ()
((_ Op func)
(Adjuk-szintaxis op
(Szintaxis szabályai ()
((_ X y)
(Begin (set! X (funk x y)) x)))))))

(Adjuk-szintaxis ++
(Szintaxis szabályai ()
((_ I)
(Begin (set! I (+ i 1)) i))))

(Definiálása-szintaxis -
(Szintaxis szabályai ()
((_ I)
(Begin (set i (-! I 1)) i))))

(Definiálása x1 2)
(Definiálása x2 3)
(Message "x1 =" x1 "; x2 =" x2)
(++ x1)
(+ = X2 (- x2))
(Message "x1 =" x1 "; x2 =" x2)
(+ = X1 X2) (message "x1 =" x1)
(* = X1 X2) (message "x1 =" x1)
(- = x1 x2) (message "x1 =" x1)
(/ = X1 X2) (message "x1 =" x1)

4. kikészítéséhez, bezárások és a magasabb rendű funkciókat.

Most primerchik a kikészítéséhez (így a függvény n paraméterként függvényében egy argumentuma, visszatér függvényében n-1 érvek) és a magasabb rendű funkciók (funkciók, hogy működnek egyéb funkciók):

(Adjuk meg (make-val-lista v0 dv VN)
(Adjuk meg (make-lista v)
(Ha (= v Vn)
(Cons v # 039 ())
(Cons V (make-listát (+ V DV)))))
(Make-lista v0))

(Definiálása A-lista (make-Val-1-lista-1 3))
(Adjuk meg X-lista (make-Val-lista 0,2 0,1 1.2))

(Definiálása (y A)
(Lambda (X) (- (* A x) (tan (* pi (/ x 4))))))

(Adjuk y-lista (térkép (lambda (A)
(Térkép (y A) X-lista))
A-list))

(Display (térkép (lambda (ls) (max alkalmazni ls)) y-lista))

Ebben a kódot, a funkció a (x, A) csökken a y (A), egy visszaállító funkció-(x), azaz lehetne alkalmazni az alábbiak szerint:

(Legyen ((A1 1) (X1 0,2))
((Y A1) x1))

Kikészítéséhez nagyon hasonlít az áramkör jól értem, egyetlen hibája látható a következő lépéseket:

(Definiálja y1 (y 1)); létrehozásához funkció (y1 x) = (- (* 1 x) (tan (* pi (/ x 4))))
(Y2 (y 2)); létrehozásához funkció (y1 x) = (- (* 2 x) (tan (* pi (/ x 4))))
(Y1 x1)
(Y2 x1)

A példában használt magasabb rendű funkciók feltérképezése és alkalmazni, hogy a munka az alábbiak szerint:

1) térkép a továbbított alkalmazza függvényében a neki átadott minden elem a lista által továbbított második érvet, majd visszaadja az értékek rezultattov alkalmazás, például

(Adjuk teszt-lista # 039 (-2 1 7 0 -5 4))
(Térkép absz teszt-lista); visszaküld egy listát az abszolút érték meghatározására a vizsgálandó-lista LOV: (2 1 7 0 5 4)

2) alkalmazni vonatkozik vezetjük rá, mint az első érv, hogy az elemek a lista által továbbított második érv,
Bud ők (lista tétel) paraméterek át funkciók, mint függvények

(Max -2 1 7 0 4 -5); \
(+ -2 1 7 0 -5 4); _vernut maximális értékét és az értékek összege továbbított paramétereket, ill.

hanem egy kísérlet okoz számukra, így:

(Max teszt-lista). \
(+ Teszt-lista); _vydast hiba.

Ez nem túl hasznos, ha például a program során létrehozott értékek listája, ahonnan ki kell választania a maximális értéket, vagy az összeg számít. És akkor jön a támogatás alkalmazni függvény, amely bemutatja, hogy milyen-felsorolni, azaz a. E. Expression

(Alkalmazás max teszt-lista); \
(Alkalmazás + teszt-lista); _ekvivalentny kifejezések
(Max -2 1 7 0 4 -5); \
(+ -2 1 7 0 -5 4); _sootvetstvenno.

És a végén megy vissza szíj. Amint látható a leírás a térkép funkciót, akkor csak akkor működik egyváltozós függvényeket. Ekkor fel nekünk, és jön a támogatás = kikészítéséhez és zárás).

5. Egy kicsit a makrók és a tetszőleges számú argumentum.

Ahogy talán már észre, néhány funkció és az űrlapok bármilyen számú argumentum, mint például:

(+ 1 2 3)
(+ 1 2 3 4)
(És exp1 EXP2)
(És exp1 EXP2 exp3 exp4)

Ahhoz, hogy egy ilyen funkció, akkor kell használni dot felvétel érvek, például:

(Adjuk meg (üzenet fejét. Tail)
(Display fej)
(For-mindegyik kijelző farok)
(Új sor))

Ebben a meghatározásban a függvény az első érv kerül átadásra közvetlenül a paraméter fej, és a többiek - a lista farka. Ez használ egy másik, magasabb rendű függvény-minden, ami vonatkozik a funkció telt, mint az első érv, hogy minden eleme a lista által továbbított második érv, de ellentétben a térkép függvény nem ad vissza értéket. Most már használhatja az üzenet funkció:

(Message "Hello World!")
(Legyen ((world "világ"))
(Message "Hello" világ "!"))

Határozza meg a formája, hogy vesz bármennyi érv, hogy lehetséges ilyen módon:

(Definiálása-szintaktikai és
(Szintaxis szabályai ()
((_) #t)
((_ E) e)
((_ E1 E2 e3.)
(Ha az E1 (és e2 e3.) #f))))

Akkor tudod használni az új formája a következő:

Ezzel vége a felülvizsgálatot. Remélem, ő volt / lesz valakinek hasznos valakinek érdekes. =)