Eiffel (programozási nyelv)

Az Eiffel programozási nyelvet Bertrand Meyer tervezte az 1980-as évek közepén. Objektumorientált programozási nyelv, amely jellegzetesebb tulajdonságai közé tartozik a többszörös öröklődés és a szerződésalapú programozás. A nyelv a nevét Gustave Eiffel francia építészről, az Eiffel-torony és a budapesti Nyugati pályaudvar tervezőjéről kapta. A nyelv szintaxisa a Pascalra és az Adára hasonlít. Erősen típusos, tisztán objektumorientált nyelv. A programnyelvet úgy tervezték meg, hogy a program kódja maga legyen a dokumentáció. Meyer, a nyelv alkotója, saját céget alapított, Eiffel Software néven, amelyik a programnyelv fejlesztésére szakosodott. Saját implementációjuk az EiffelStudio.

Elvek Az Eiffel objektumorientált, és ezt igyekszik minél következetesebben megvalósítani. A programkönyvtárak és az alaptípusok is osztályok. A programkönyvtárak használata is objektumorientált: örökölni kell belőlük.

Az azonos osztályú objektumok nem látnak bele jobban egymás belsejébe, mint más kliensek. Sok más nyelvvel, például a C++-szal és a Javával ellentétben a leszármazott osztály példányai korlátozások nélkül hozzáférhetnek azokhoz a feature-jeikhez is, amelyeket az alaposztályból örököltek. Tehát az Eiffel nyelv a többi, osztályorientált nyelvvel szemben objektumorientált.

Engedélyezi a többszörös öröklődést, és a gyémántprobléma megoldására több eszközt is kínál. Sem az összeolvasztás, sem a szétválasztás nem automatikus. A probléma megoldását a programozóra bízza, és ehhez nyelvi eszközöket is kínál.

A nyelv tervezésében fontosak voltak a kényelmi szempontok és az intuíció támogatása is. A leszármazottakban a láthatóság akár szűkíthető is. A rutinok paraméterkészlete, értelmezési tartománya szűkíthető. Ha G generikus osztály, és B alosztálya A-nak, akkor G[B] is alosztálya G[A]-nak, holott az elmélet a másik irányt indokolná. Ezekkel az eszközökkel egyszerűen megvalósíthatók olyan megkötések, amelyek más nyelvekben bonyolult, vagy akár lehetetlen lenne megvalósítani. Mindezek az eszközök azonban aláássák a típusbiztonságot, tehát a típusok nem bizonyítják a program helyességét. A problémán a polimorfikus catcall segíthet.

A nyelv alapelvei közé tartozik az általánosítás is. A nyelvhez csatolt módszertanban a projekt külön fázisában végzik az általánosításokat, a projektben szereplő osztályok generikussá tételét. A generikusság korlátozható közös ősosztállyal. Ennek az a hátránya, hogy a közös ősbe be kell tenni minden műveletet, amire hivatkozni kívánunk. Ez részletes előzetes tervezést igényel. Az ágensek segíthetnek megkerülni ezt a kérdést.

A helyesség ellenőrzésére az elő- és utófeltételek, meg az invariánsok szolgálnak. Közös néven szerződéseknek nevezik őket, és a vállalkozók közötti szerződésekhez hasonlítják. Még az ős és a leszármazott osztályok is szerződnek, ahol is a leszármazott kapja az alvállalkozó szerepét. Az egyes objektumokban a privát rutinok belsejében nincsenek szerződések; az egyes objektumnak nem kell önmagával szerződnie, de az invariánst a művelet elvégzése után biztosítania kell.

Szintaxis és szemantika Az Eiffel nyelv csak az ASCII karaktereket fogadja el. Ha más karakterek bukkannak fel, akkor a fordító hibát jelez. Beépített típusok Az Eiffel beépített elemi típusai:

INTEGER, REAL, DOUBLE, CHARACTER, BOOLEAN.

A fordító ismeri még a STRING, az ARRAY és a BIT_N (bitsorozat típus) típust is. Mindezek a típusok nullaszerű értékre inicializálódnak az INTEGER 0-ra, a REAL 0.0-ra, a DOUBLE 0.0-ra, a CHARACTER nullkarakterre és a BOOLEAN False-ra.

Konvenciók Maga a nyelv nagybetű-érzéketlen: a kis- és a nagybetűk használatát konvenciók szabályozzák. A nevekben csak ASCII karakterek szerepelhetnek; a neveket betűvel kell kezdeni, de a továbbiak lehetnek betűk, számok és aláhúzásjelek is. Az aláhúzásjel a több szavas nevek tagolására szolgál. Az osztályok neve a konvenció szerint csupa nagybetűből áll. A konstansok nagybetűvel, a többi feature kisbetűvel kezdődik. Az előre definiált entitások és kifejezések szintén nagybetűsek. A nagybetű-érzéketlenség ellenére lehetséges egy osztály példányának az osztály kisbetűs nevét adni.

A ; tagolásra szolgál. A sorok végén kitehető, de nem hiba, ha nincs.

Konstans megadása például: Solar_system_planet_count: INTEGER = 9

Vezérlési szerkezetek A feltételes utasítás így néz ki:

if feltetel then --utasitasok elseif feltetel then --utasitasok else --utasitasok end

ahol akárhány elseif utasítás lehet, és ha nincs elseif, akkor else sem kötelező.

Többszörös elágazás írható ezzel is:

inspect --egesz, vagy karakter kifejezes when ertek1,ertek2 then utasitas when ertek3..ertek4 then utasitas else utasitas end

A ciklus:

from --kezdofeltetel invariant --invarians variant --ciklusvaltozo until --amig nem loop --ciklusmag end

ahol is az invariant és a variant nem kötelező.

Rutinok A rutinok a Result változóban levő értékkel térnek vissza.

A paraméter nélküli rutinok zárójel nélkül hívhatók. Ez lehetővé teszi, hogy egy absztrakt osztály egyik konkrét utóda kiszámítsa azt, ami egy másik leszármazottban attribútum.

A once rutinok csak első meghívódásukkor futnak le, a későbbiekben ennek a futási eredménye érhető el ugyanazzal a névvel. Általában paraméter nélküli, de lehetnek paraméterei is. Ezekben a rutinokban a do helyett once szerepel.

Az elavult rutinok a obsolete utasítással jelölhetők meg. Ennek egy string a paramétere, amiben leírható, hogy mit használjunk helyette.

A felülírás letiltható a frozen deklarációval.

Ágensek A rutinok ágensbe burkolva átadhatók paraméterként. Ezek az ágensek azonban nem azonosak a robotok programozásában használt ágensekkel.

Legyen az r rutin definiálva a C osztályban. Ekkor a C.r rutinból ágens készíthető:

class C feature --... r(parameterek) do --a rutinban megvalositott tevekenyseg end agent r end

Az agent r kifejezés szerepelhet azokban az osztályokban is, amelyekből az r rutin egyébként is hívható lenne. Ha az r rutinnak vannak paraméterei, akkor többféleképpen is átadható, mint ágens:

agent r(a,?)

azt jelenti, hogy az első paraméter az a, a második paraméter nyitott. Hasonlóan,

agent r(?,b)

jelentése az, hogy az első paraméter nyitott, a második paraméter a b. De lehet ilyen is:

agent r(a,b)

itt minden paraméter meg van adva, de a behelyettesítés még nem történt meg, hanem arra vár, hogy meghívják az ágenst.

Lehet akár ilyen is:

agent r(?,?)

ami ugyanazt jelenti, mint

agent r.

Osztályok Osztályok a class kulcsszóval deklarálhatók. Az Eiffel programok osztályokból állnak. A beépített típusok és a programkönyvtárak is osztályok. A többszörös öröklődés és az ismételt öröklődés megengedett. A metódusokat és az osztály- és példányváltozókat, konstans tagokat a nyelv közös néven feature-nek nevezi. Alapelveiben szerepel az egységes kinézet elve, ami szerint a paraméter nélküli tagfüggvények zárójel nélkül hívhatók. Ez lehetőséget biztosít arra, hogy egy absztrakt osztály két leszármazottja közül az egyikben kiszámoljuk azt, amit a másikban megadunk.

Az osztályokban kiemelt szerep jut a létrehozó feature-öknek. Ezek a konstruktoroknak felelnek meg. A létrehozó feature-öket az osztály elején a create mondatban kell felsorolni:

class HELLO_WORLD create make feature make do print ("Hello, world!") end end

A létrehozó rutinok szokásos neve make. Ezt nem egyszerű átállítani, ezért javasolt, hogy az egyik létrehozó rutin a make legyen. Ezek a rutinok indíthatók el példányosításkor:

create x.make(a : INTEGER, b : STRING, c : ACCOUNT) Osztályon belül nincs túlterhelés, de különböző osztályokban szabad egy műveletet ugyanazon a néven deklarálni.

Absztrakt osztályok és rutinok a deferred kulcsszóval deklarálhatók. Egy absztrakt osztály utódai mindaddig absztraktak maradnak, ameddig az absztrakt rutinokat nem implementálják. Konkrét osztályok utódai is absztrakttá tehetők ugyanezzel a kulcsszóval. Az absztrakt osztályok közvetlenül nem példányosíthatók, csak konkrét utódaik révén.

Az osztályok alapesetben referenciák révén példányosulnak. Ha ezt nem akarjuk, akkor az osztályt expanded-nek kell deklarálnunk. Nem expanded osztályok példányai is lehetnek nem referenciák, ha expanded-ként hozzuk létre őket. Az alaptípusok is expanded osztályok.

expanded class PONT feature x, y : REAL eltol(dx, dy : REAL) do x := x + dx y := y + dy end end

Az üres referencia a Void, ami a NONE fiktív osztály egyetlen példánya. Ha egy osztály attached, akkor az ilyen osztályú objektumok nem lehetnek Voidok. Az expanded osztályok implicit attached tulajdonságúak is, mivel nem referenciák. Az attached ellentéte a detachable. Újabban az attached az alapértelmezett, de a régebbi verziókban a detached volt az alapértelmezés. Kompatibilis módban megint a régebbi verzió az érvényes. Erre külön figyelni kell. Az attached típusú tagok nem vehetnek fel detached típusú értéket. Ez alól kivétel, ha egy elágazásban ellenőrizzük, hogy nem Void-e.

Az alacsony szintű mutatókat a POINTER osztály példányai pótolják.

Az osztályokban Current jelöli az adott példányt. Az adott példány dinamikus típusára a like Current utal. Ez lehetővé teszi, hogy a rutinok értelmezési tartománya szűküljön az öröklődés folyamán, ami veszélybe sodorja a típusbiztonságot, hiszen az értelmezési tartomány nem szűkíthető típusbiztonságos módon. Ezen a catcall segíthet.

Öröklődés A többszörös öröklődés megengedett:

class D create --... inherit A B feature --...

ahol is az ősosztályok nem fontosságuk szerint csökkenő sorrendben vannak felsorolva, mint a Python nyelvben, hanem egyenrangúak. Névütközés esetén a fejlesztő döntheti el, hogy összevonja-e a feature-öket, vagy elkülöníti. Ehhez az Eiffel nyelvi szinten is biztosít eszközöket.

Egy feature átnevezhető (remane mondat), absztrakttá tehető (undefine mondat), vagy újradefiniálható (redefine mondat). Újradefiniálás esetén Precursor jelöli az eredetit. Átnevezés és elkülönítés esetén a select jelöli ki, hogy mi fog meghívódni az eredeti néven. Ha több absztrakt feature-t örököl az osztály, akkor elég hozzá egy implementációt írni. Meyer ezt úgy fejezi ki, hogy egy konkrét kővel több absztrakt madarat meg lehet ölni.

A létrehozó rutinok öröklődnek, de az utódokban már nem lesznek automatikusan létrehozó rutinok. Azokat minden újabb osztály elején új create mondattal be kell jelenteni.

Az öröklődésben az osztályoknak van egy közös őse, az ANY. Ez implementál néhány hasznos feature-t, mint a copy, a clone vagy a deep_clone. Van benne egyenlőségvizsgálat, amely az objektumok egyenlőségét vizsgálja. További egyenlőségvizsgálatra szolgál az equal és az is_equal. Ezek a rutinok felüldefiniálhatók az utódokban, de mindegyikhez tartozik egy alapértelmezett, aminek neve default_-tal kezdődik, és ami nem definiálható át. Az egyenlőségvizsgálatban = jelöli az egyenlőt, és /= a nem egyenlőt. A ~ az equal alapján készül. Az := értékadás mellett feltételes értékadás is van, a ?=. A példányok fájlba menthetők: x.store(fajl_neve). Az ANY bővíthető is, de szülője, a GENERAL már nem.

Az összes osztálynak van egy közös utóda, a NONE fiktív osztály, aminek csak egy eleme van, az üres referencia, a Void.

Az ANY és a NONE az exportlistákban válik fontossá:

export{ANY} feature xyz

azt jelenti, hogy az xyz feature bárhonnan látható,

export{NONE} feature

pedig azt, hogy az adott objektumon kívülről még az azonos osztályú példányok sem férhetnek hozzá. A többi eset ezek között áll, a kapcsos zárójelek között felsorolt osztályú objektumok láthatják az osztály adott feature-ét. Ez a láthatóság finomabb szabályozását teszi lehetővé.

Szerződések