Az Opal programozási nyelv

Típusok, típuskonstrukciók

Az OPAL nem tartalmaz előre definiált típusokat. (Általában a fordítók azért, kettőt mégis használnak: a boolean-t és a denotations-t). Természetesen az OPAL is tartalmaz típusokat, de ezek standard könyvtárakban vannak deklarálva (pl.: egészek, valós számok, karakterek, stringek, hasonlóan ahhoz, ahogy a bonyolultabb struktúrák: listák, tömbök, fák stb.).

A következő típuskonstrukciós műveleteket támogatja a nyelv:

Felsorolási típus

TYPE color == red blue yellow green cyan orange

Ezzel a deklarációval létrejött egy új halmaz "color" névvel, mintha az szerepelne a programban, hogy:

SORT color

Ez a halmaz hat elemet tartalmaz. Az definiálás következő konstansokat generálja:

FUN red : color
FUN blue : color
FUN yellow : color
FUN green : color
FUN cyan : color
FUN orange : color

Plusz a hozzá tartozó lekérdező függvényeket:

FUN red? : color -> bool
FUN blue? : color -> bool
FUN yellow? : color -> bool
FUN green? : color -> bool
FUN cyan? : color -> bool
FUN orange? : color -> bool

Rekord típus

A következőképpen lehet rekord típust definiálni:

TYPE person == person ( name : string,
 firstName : string,
 id : nat)

Ahogyan az előbb volt ez most is eredményezi a:

SORT person

Az ebbe a típusba való elemeket az alábbi függvénnyel lehet előállítani:

FUN person : string ** string ** nat -> person

Szóval egyszerűen a: person("Chaplin","Charles",1234) a megfelelő típusú elem lesz. A colorhoz hasonlóan létezik a personnak is lekérdező függvénye:

FUN person? : person -> bool

Bár ez nem igen használható.

Viszont igen fontos, hogy a rekord komponenseit visszakaphassuk. Ez a szelektorokkal tehetjük:

FUN name : person -> string
FUN firstName : person -> string
FUN id : person -> nat

Unió típus

Ez teremti meg a lehetőségét, hogy egy struktúra többféle információt tárolhasson:

TYPE person == single ( name : string, firstName : string)
 married ( name : string, firstName : string, spouse : string)
 widowed ( name : string, firstName : string, dateOfDeath : date)
 divorced( name : string, firstName : string, dateOfDivorce:date)

 

SORT person

A következő függvényekkel állítható elő ilyen elemek:

FUN single : string ** string -> person
FUN married : string ** string ** string -> person
FUN widowed : string ** string ** date -> person
FUN divorced: string ** string ** date -> person

Le is lehet kérdezni a tartalmát a következő függvényekkel:

FUN single? : person -> bool
FUN married? : person -> bool
FUN widowed? : person -> bool
FUN divorced? : person -> bool

Végül néhány szelektor:

FUN name : person -> string
FUN firstName : person -> string
FUN spouse : person -> string
FUN dateOfDeath : person -> date
FUN dateOfDivorce: person -> date

Rekurzív típus

TYPE person == single ( name : string, firstName : string,  father: person, mother : person)  married ( name : string, firstName : string,  spouse : string, father: person, mother : person,  spousesFather: person, spousesMother : person)  widowed ( name : string, firstName : string,  dateOfDeath : date, father: person, mother : person)  divorced( name : string, firstName : string,  dateOfDivorce : date, father: person, mother : person)

Ahhoz, hogy a rekurzió véges legyen, még kell egy lépés:

TYPE person == single ( name : string, firstName : string,  father: person, mother : person)  married ( name : string, firstName : string,  spouse : string, father: person, mother : person,  spousesFather: person, spousesMother : person)  widowed ( name : string, firstName : string,  dateOfDeath : date, father: person, mother : person)  divorced( name : string, firstName : string,  dateOfDivorce : date, father: person, mother : person)  unknown

Itt az unknown egy freetype típus.

Paraméteres típus

Nagyon fontos eleme egy nyelvnek, ha támogatja a paraméterezhető típusokat, mert így javítja az újrafelhasználhatóságot. Klasszikus példa erre a sor, mivel a sor implementálásánál lényegtelen, hogy a sorban számok, karakterek, vagy a person típus elemei találhatók.

Példának bemutatok egy leegyszerűsített sort:

SIGNATURE Seq[data]
SORT data

IMPORT Nat ONLY nat

TYPE seq == ::(ft :data, rt : seq) /* as free type */
 <>
FUN # : seq -> nat /* length of a seq */
>>> egy csomó függvény <<<

Az implikációs rész:

IMPLEMENTATION Seq[data]

IMPORT Nat ONLY 1 +

DATA seq == ::(ft :data, rt : seq) /* implementation of */
 <> /* free type */

DEF # (s) == IF ::? (s) THEN 1 + #(rt(s))
 IF <>?(s) THEN 0 FI

>>> a többi függvény definíciója <<<