Az Emerald programozási nyelv

Típusok

Egy absztrakt típus a mûveletek szigantúrájának csoportjaként van definiálva, ahol az egyes mûveletek szignatúrája tartalmazza a mûveletek nevét, a pareméterek és értékek nevét és típusát.
Minden típusobjektum exportál egy paraméter nélküli getSignature függvényt, amely visszatér egy elôredefiniált Signature típus objektumával. Más szavakkal, bármely objektum amely megfelel a következô típusnak: 

	immutable type aType
		function getSignature -> [Signature]
	end aType
az egy típus.
Jegyezzük meg, hogy minden objektumnak signature típussal van egy getSignature mûvelete, amely visszaadja a cél objektumot, így ezek a Signature-ák Típusok.

Típus konstrukciók

A típusok a típuskonstruktorok által jönnek létre. A típuskonstruktorok struktúrája a következô: 

	typeConstructor ::= [immutable] type typeIdentifier
				{operationSignature}
			end typeIdentifier
Az azonosítók paraméter deklarációkban mellôzhetôek. A változtathatatlan típusból következi, hogy annak objektumai is változtathatatlanok, azaz ezen objektumok értékei nem változtathatók.
Például: az elôredefiniált integer típus is megváltoztathatatlan, mert az objektumai integer értéket reprezentálnak, melyek nem változtathatók. Pl. az integer 3-at nem lehet 4-re változtatni. 
	type Directory
		operation Add [name : String, thing : Any]
		operation Lookup [name : String] -> [thing : Any]
		operation Delete [name : String]
	end Directory
Ez a konstruktor végrehajtható és mikor végrehajtódik akkor létrehoz egy nem változtatható objektumot, mely illeszkedik az AbstractType-hoz. A getSignature végrehajtása az eredményül kapott objektumon önmagát adja vissza: egy típus 3 mûveletet igényel: Add, Lookup és Delete

Hasonlóság

Néhány típus a rendszerben kivétel a szabványos hasonlósági és egyezôségi szabályoknak. Hogy biztosak legyünk a helyességben az olyan típusoknak mint a Boolean, Condition, Node, Signature és Time a rendszer által implementáltnak kell lennie. A teljesítmény növelése érdekében Character, Integer, Real és String típusoknak is a rendszerben kell lenni implementálva.

Egyéb típusok

Az Emerald 4 szintaktikai röviditést definiál az általánosan elõforduló szerkezetekre.

Osztályok

Az Emeraldban nincs osztályfogalom, de lássuk be, hogy gyakran kényelmes, hogy osztályok használatával programozzuk. Ennek következtében az Emerald forditó támogat egy szintaktikus kiterjesztést: az osztályt, és támogatja az öröklõdés formáját (makrókkal). 
	class		::= class identifier ["("baseClass")"][parameterlist]
				{classoperation}
				{declaration}
				[monitor|initially]
				{operation}
				[process]
			end identifier
	baseClass	::= identifier
	classoperation	::= class operation
Az öröklõdés szintaktikus. Minden komponens az õs osztályban, ami nincs újradefiniálva a leszármazottban. Mivel bármely komponens újradefiniálható nincs garancia arra, hogy a leszármazott meg fog felelni az õ õsének.

Összetett típusok

Felsorolási


enum	::=	enumeration identifier
				enumIdentifier{"," enumIdentifier}
			end identifier

A felsorolási típus mûveletei: first, last, <, <=", ">, >=, =, !=, succ, pred, ord, asString.

Mezõ

field	::=	[attached] field identifier : type [initializer]
		|	[attached] const field identifier : type initializer

Gyakran kényelmes, hogy kívülrõl elérhetõ adatelemet deklaráljunk az obejktumban. A mezõ deklaráció pontosan ezt csinálja. Mezõ delkaráció csak az objektum konstruktor deklarációs részében fordulhat elõ. Mindegyik mezõ deklaráció kiegészül egy változó deklarációval és két mûvelet definíciójával (elsõ esetben) vagy egy konstans deklarációra és egy mûvelet definícióra (második esetben)
A kibõvités így történik: 

	attached field a : b <- c
is
	attached var a : b <- c
	export operation setA[x:b]
		a <- x
	end setA
	export function getA -> [x:b]
		x <- a
	end getA
Ahol az x azonosító úgy van választva, hogy ne ütközzön más azonosítóval.
Konstans mezõk konstans deklarációk lesznek és csak getA mûveletük lesz. 


Rekord
	record	::=	[immutable] record identifier
				field { field }
			end identifier;
	field	::=	[attached] var fieldIdentifier : type


Példa:	immutable record aRecord
	   var a : b
	   var c : d
	end aRecord
Osztályra kiterjesztve:
	immutable class aRecord[xa : b, xc : d]
	   field a : b <- xa field c : d <- xc end aRecord

Az Emerald szintaktikusan megengedi, hogy elérjük a mezõket a rekordhoz hasonló objektumokban.
A szintaktikai formája: 

	filedSelection	::= expression "$" identifier
	subscript	::= expression "[" expression { "," expression } "]"