Prognyelvek portál

Ez a függelék a harmadik fejezet anyagának kiegészítése (a beépített típusok és paraméteres típusok előzetes leírásának).

Minden beépített típus -kivéve az "any"- rendelkezik "equal", "similar", "copy" és "unparse" metódusokkal. Ezek a metódusok opcionálisak a paraméterezett típusoknak, mint pl. "array[T]": egy példányosítás csak akkor fog rendelkezni ezen metódusok valamelyikével, ha mindegyik aktuális paraméter típusa rendelkezik a metódussal.

A beépített típusok és a paraméterezett típusok egyike sem rendelkezik altípussal, kivéve az "any", ami miden típusnak szupertípusa. Az összes többi beépített típusnak nincsen típushierarchiai kapcsolata, kivéve a gazdag hierarchiával rendelkező rutin típust.

A beépített és paraméterezett típusok olyan osztályokként vannak implementálva, amelyek nem rendelkezhetnek altípusokkal.

A Theta környezet tartalmaz számtalan egyenlőséget (azonosságot), amelyek leírják a beépített típusok különböző tulajdonságait és megszorításait. A megfelelő típusok definícióit ebben a fejezetben ezek az egyenlőséget írják le részletesen.

Any

Az "any" típus szupertípusa az összes típusnak. Nincsenek metódusai és társított rutinjai.

Null

A "null" egy immutable típus egy egyszerű objektummal, amit a "nil" jelöl. Elsősorban a "oneof"-nál használható, az "empty" ágra mutat.

A "null" típus metódusai:

  equal (n: null) returns (bool)
      % igazat ad vissza.
  similar (n: null) returns (bool)
      % igazat ad vissza.
 
  copy ( ) returns (null)
      % nil értéket ad vissza.
 
  unparse ( ) returns (string)
      % visszaad egy három karakterből álló sztringet (``nil'').

Bool

A "bool" típus egy immutable típus két objektummal, amelyeket a "true" és "false" literál jelöl.

A "bool" típus metódusai:

  not ( ) returns (bool)
      % a másik értéket adja vissza (negáltját önmagának).
 
  and (x: bool) returns (bool)
      % visszaadja saját maga és x "éselésének" értékét.
 
  or (x: bool) returns (bool)
      % visszaadja saját maga és x "vagyolásának" értékét.
  
  xor (x: bool) returns (bool)
      % visszaadja saját maga és x "xor" értékét.
  
  equal (x: bool) returns (bool)
      % akkor ad igazat, ha mindkettő (x és önmaga) "true" vagy
      % mindkettő "false"; egyébként hamisat ad.
 
  similar (x: bool) returns (bool)
      % akkor ad igazat, ha mindkettő (x és önmaga) "true" vagy
      % mindkettő "false"; egyébként hamisat ad.
  
  copy ( ) returns (bool)
      % önmagát adja vissza.
 
  unparse ( ) returns (string)
      % ha értéke "true"-val egyenlő, akkor "true" sztringet,
      % ellenkező esetben a "false" sztringet adja vissza.

Int

Az "int" típus egész számok objektumának részhalmazát tartalmazzák. Objektumai immutable típusúak.

Az "Int" számtalan literál formával rendelkezik az objektumaira. Az "Int" értéket jelölhetjük akármilyen számrendszerben 2 és 36 között, a következő forma felhasználásával:

<integer_literal> -> [ <base> "_" ] <integer_digits>

A bázist és az aláhúzást elhagyva az alap bázis-érték a tizes számrendszer. A bázis decimális számként tárolja, és 2 valamint 36 között kell lennie. Egy szám számjegyeit az 0-9 számjegyekkel jelöljük, és ha szükséges az abc alkalmas betűivel. Például, 16-os számrendszer esetén a használt számjegyek "0-9", és "a-f". Az abc kis és nagybetűit azonosnak tekintjük az egész számokban. Nem engedélyezett szóköz az egész számon belül. Itt találtató néhány példa literál az ő helyes tizes számrendszerbeli értékével együtt:

literál         tizes számrendszerben
25              25
10_25           25
16_1c           28
16_1C           28
8_72            58
3_2001          55
2_1101          13

A következő konstansok a Theta környezetben jelölik az ábrázolt egész számok határait.

int_max        egész szám jelöli a legkisebb ábrázolható egész számot
int_min        egész szám jelöli a legnagyobb ábrázolható egész számot

Az egész számok ábrázolása 32 bites történik, emiatt egy kettes komplemenst használó gépen az "int_min" (-2^31) lesz, az " int_max" pedig (2^31-1).

Az "Int" típus metódusai:

  negate ( ) returns (int) signals (overflow)
      % A mínusz egyszeresével tér vissza, overflow kivétel akkor váltódik ki,
      
% ha a visszatérési érték nincs az ábrázolható határok között.
  add (x: int) returns (int) signals (overflow)
      % önmagához ad x-et, a visszatérési érték az összeg, overflow kivétel akkor váltódik ki,
      
% ha a visszatérési érték nincs az ábrázolható határok között.
 
  subtract (x: int) returns (int) signals (overflow)
      % önmagából kivon x-et, a visszatérési érték az kivonás eredménye, overflow kivétel akkor váltódik ki,
      % ha a visszatérési érték nincs az ábrázolható határok között.

 
  multiply (x: int) returns (int) signals (overflow)
      % önmagát megszorozza x-szel, a visszatérési érték az szorzás eredménye, overflow kivétel akkor váltódik ki,
      
% ha a visszatérési érték nincs az ábrázolható határok között. 
  divide (x: int) returns (int) signals (zero_divide, overflow)
      % Ha x=0, akkor váltódik ki a zero_divide kivétel,
      % minden más esetben önmagát osztja x-szel, a visszatérési értéket a negatív végtelen felé kerekíti.
      
% Overflow kivétel akkor váltódik ki, ha a visszatérési érték nincs az ábrázolható határok között.
 
  mod (x: int) returns (int) signals (zero_divide)
      % Ha x=0, akkor váltódik ki a zero_divide kivétel,
      
% minden más esetben önmagát maradékos osztást hajt végre x-szel.
      % Ezt az értéket kapjuk az x-szel való osztás maradékaként, és self = (self/x) * x + self.mod(x). 

 
  power (x: int) returns (int) signals (negative_exponent, overflow)
      % Ha x<0, akkor váltódik ki a negative_exponent kivétel,
      
% minden más esetben önmagát az x-edik hatványra emeli.
      % Ha self = 0 (önmaga), akkor self.power(0)-t 1-nek definiáljuk.
      
% Overflow kivétel akkor váltódik ki, ha a visszatérési érték nincs az ábrázolható határok között.
 
  abs ( ) returns (int) signals (overflow)
      % A visszatérési érték önmagának az abszolút értéke.
      % Overflow kivétel akkor váltódik ki, ha a visszatérési érték nincs az ábrázolható határok között.

 
  to (bound: int) yields (int)
      % Felsorolja az egész számokat önmagától bound-ig sorban; ha bound < önmaga akkor semmit sem ad vissza.
 
  to_by (bound: int, step: int) yields (int)
      % Felsorolja az egész számokat önmagától step lépésközzel (self, self + step, ...) bound-ig (bound-ot beleértve).
 
  max (x: int) returns (int)
      % Önmaga és x közül a nagyobbikkal tér vissza.
 
  min (x: int) returns (int)
      % Önmaga és x közül a kisebbikkel tér vissza.
 
  lt (x: int) returns (bool)
      % Igaz értékkel tér vissza, ha önmaga < x.
 
  le (x: int) returns (bool)
      % Igaz értékkel tér vissza, ha önmaga <= x.
 
  gt (x: int) returns (bool)
      % Igaz értékkel tér vissza, ha önmaga > x.
 
  ge (x: int) returns (bool)
      % Igaz értékkel tér vissza, ha önmaga >= x.
 
  equal (x: int) returns (bool)
      % Igaz, ha önmaga egyenlő x-szel.
 
  similar (x: int) returns (bool)
      % Igaz, ha önmaga egyenlő x-szel.
 
  copy ( ) returns (int)
      % Önmagával tér vissza.
 
  unparse ( ) returns (string)
      % Tizes számrendszerbeli értékét adja vissza egy sztringben.
      
% pl. ha a szám=123, akkor egy három karakterből álló sztringet ad vissza (``123'').
  
  to_real ( ) returns (real)
      % Valós számmá konvertálja magát, és ezt adja vissza; nulla felé kerekít
      
% határa lesz a valós számok határának és a saját határainak fedése.
 
  to_char ( ) returns (char) signals (illegal_char)
      % Ha önmaga egy karakter ASCII kódját jelenti, akkor azzal a karakterrel tér vissza,
      
% különben illegal_char kivételt vált ki.

Real

A "real" típus egy immutable típus, lebegőpontos szám. Egy részhalmaza a IEEE sima-pontosságú lebegőpontos számainak, a következő változtatásokkal:

pozitív és negatív végtelen nem ábrázolható
pozitív és negatív nulla nem különböztethető meg
nem szabványosított értéket nem használhatók

A következő konstansok a Theta környezetből a határok specifikációját írják le, a valós számok pontosságának és a formájának leírása a Theta-ban:

real_emin           az egész érték jelzi a legkisebb bináris exponens értékét
real_emax           az egész érték jelzi a legnagyobb bináris exponens értékét
real_precision      az egész érték azt mutatja, hogy hány számjegyig pontos az ábrázolás a "real" típusnál

A következő értékek leírják az értéket határát és a pontosságot:

real_max            a valós típusú érték megmutatja legnagyobb lehetséges valós számot
real_min            a valós típusú érték megmutatja legkisebb lehetséges normalizált (szabványosított) valós számot
real_epsilon        a valós érték megmutatja a törtrész legkisebb értékes (lényeges) pozíciót, ahol ahol exponens nulla
real_round_style    a felsorolási érték jelzi a kerekítés módját: 
                                  real_round_toward_zero
                                  real_round_toward_minus_infinity
                                  real_round_other

megjegyezzük, hogy:

real_max        = (1-2^(-real\_precision))*2^(real\_emax)
real_min        = 2^(real\_emin-1)
real_epsilon    = 2^(1-real\_precision)

A valós literálok a következő formák valamelyikét követik:

<real_literal> -> [ <digits> ] "." <digits> [ <exponent> ]
               |  <digits> <exponent>
<exponent> -> "e" [ "+" | "-" ] <digits>
           |  "E" [ "+" | "-" ] <digits>

ahol a 'digits' nem üres sorozata a 0-9 számjegyeknek. Real_literal-on belül szóköz nem megengedett. Itt van pár példa megengedett real_literal-okra:

2.6
25.0
.05
5.2e-3
5.2e+3
2e10
.02E2
.0E5

Jegyezzük meg, hogy a tizedes pontot követnie kell egy vagy több számjegynek, így a következő valós literálok nem megengedettek:

1.
45.e6

A "real" típus metódusai:

  negate ( ) returns (real)
      % A mínusz egyszeresével tér vissza.
 
  add (x: real) returns (real) signals (overflow, underflow)
      % önmagához ad x-et, a visszatérési érték az összeg.
      % Overflow kivétel akkor váltódik ki, ha a visszatérési érték túl nagy az ábrázoláshoz.
      
% Underflow kivétel akkor váltódik ki, ha a visszatérési érték közel van a nullához az ábrázoláshoz.
    
  subtract (x: real) returns (real) signals (overflow, underflow)
      % önmagából kivon x-et.
      
% Overflow kivétel akkor váltódik ki, ha a visszatérési érték túl nagy az ábrázoláshoz.
      % Underflow kivétel akkor váltódik ki, ha a visszatérési érték közel van a nullához az ábrázoláshoz.

 
  multiply (x: real) returns (real) signals (overflow, underflow)
      % önmagát megszorozza x-szel.
      % Overflow kivétel akkor váltódik ki, ha a visszatérési érték túl nagy az ábrázoláshoz.
      
% Underflow kivétel akkor váltódik ki, ha a visszatérési érték közel van a nullához az ábrázoláshoz.
 
  divide (x: real) returns (real) signals (overflow, underflow, zero_divide)
      % Ha x=0, akkor váltódik ki a zero_divide kivétel,
      
% minden más esetben önmagát osztja x-szel.
      % Overflow kivétel akkor váltódik ki, ha a visszatérési érték túl nagy az ábrázoláshoz.
      
% Underflow kivétel akkor váltódik ki, ha a visszatérési érték közel van a nullához az ábrázoláshoz.
 
  power (x: real) returns (real) signals (overflow, underflow, complex_result, zero_divide)
      % Önmagát az x-edik hatványra emeli.
      
% Overflow kivétel akkor váltódik ki, ha a visszatérési érték túl nagy az ábrázoláshoz.
      % Underflow kivétel akkor váltódik ki, ha a visszatérési érték közel van a nullához az ábrázoláshoz
      
% Zero_divide kivétel akkor váltódik ki, ha önmaga = 0 és x < 0.
      % Complex_result kivétel akkor váltódik ki, ha önmaga < 0 és x rendelkezik törtrésszel.

 
  abs ( ) returns (real)
      % A visszatérési érték önmagának az abszolút értéke.
 
  exponent ( ) returns (int) signals (undefined)
      % Azt az n számot adja vissza, amelyre igaz, hogy 2^(n-1) < önmaga < 2^(n).
      
% Undefined kivétel akkor váltódik ki, ha önmaga = 0.   
 
  mantissa ( ) returns (real)
      % Azt az x értéket adja vissza, amelyre x*2^( self.exponent() ) = self.
 
  max (x: real) returns (real)
      % Önmaga és x közül a nagyobbikkal tér vissza.

 
  min (x: real) returns (real)
      % Önmaga és x közül a kisebbikkel tér vissza.
 
  to_int ( ) returns (int) signals (overflow)
      % Visszaadja a legközelebbi egész szám felé kerekített értéket (megállapodás szerint nulla felé).
      % Overflow kivétel akkor váltódik ki, ha a visszatérési értéket nem tudjuk egész számként ábrázolni.

 
  floor ( ) returns (real)
      % Visszaadja a negatív végtelen felé kerekített értéket. 

 
  ceiling ( ) returns (real)
      % Visszaadja a pozitív végtelen felé kerekített értéket. 
  
  lt (x: real) returns (bool)
      % Igaz értékkel tér vissza, ha önmaga < x.
 
  le (x: real) returns (bool)
      % Igaz értékkel tér vissza, ha önmaga <= x.
 
  gt (x: real) returns (bool)
      % Igaz értékkel tér vissza, ha önmaga > x.

 
  ge (x: real) returns (bool)
      % Igaz értékkel tér vissza, ha önmaga >= x.
 
  equal (x: real) returns (bool)
      % Igaz, ha önmaga egyenlő x-szel.

 
  similar (x: real) returns (bool)
      % Igaz, ha önmaga egyenlő x-szel.
 
  copy ( ) returns (real)
      % Önmagával tér vissza.

 
  unparse ( ) returns (string)
      % Egy a számnak megfelelő sztringgel tér vissza.
      % Az általános forma a következő:  [-]egészrész.törtrész[e+/-exponens].

Char

A "char" típus tartalmazza az ASCII karaktereket. Ezek az objektumok immutable típusúak. A "char" literálokat sima idézőjelek közé kell helyezni. A nyomtatható ASCII karaktereket (oktális 40-től oktális 176-ig), a sima idézőjelet vagy \ karaktert leírhatjuk ha sima idézőjelek közé helyezzük. Néhány karaktert leírhatunk úgy, hogy a következő speciális jeleket tesszük a sima idézőjelek közé:

speciális jelek    karakterek
 
\'                 sima idézőjel
\"                 dupla idézőjel
\\                 backslash
\t                 vízszintes tab
\v                 függőleges tab
\n                 újsor karakter
\r                 kocsi vissza karakter
\f                 lapdobás (vagy új lap)
\b                 backspace
\\ddd              oktális érték (pontosan három oktális számjegyet specifikál)

Ha a "ddd"-ben specifikált oktális érték nem egyezik egy megengedett ASCII karakter értékével, akkor fordítási idejű hiba lesz. Példák karakter literálokra:

'', '7', 'a', '"', '\"', '\'', '\n', '\000'

A "char" típus metódusai:

  to_int ( ) returns (int)
      % Visszatér a karakter ASCII kódjával. 
 
  to_string ( ) returns (string)
      % Egy karaktert tartalmazó sztringgel tér vissza. 

 
  lt (c: char) returns (bool)
  le (c: char) returns (bool)
  ge (c: char) returns (bool)
  gt (c: char) returns (bool)
      % Ezek a függvények a karakterek ASCII kódjait hasonlítják össze.
 
  equal (c: char) returns (bool)
      % Akkor igaz, ha a c karakter egyezik önmagával. 

 
  similar (c: char) returns (bool)
      % Akkor igaz, ha a c karakter egyezik önmagával. 
 
  copy ( ) returns (char)
      % Önmagával tér vissza.

  unparse ( ) returns (string)
      % Ha a karakter nyomtatható, akkor visszatér egy őt tartalmazó sztringgel.  
      % Egyébként azzal a speciális jelsorozattal tér vissza, amely őt reprezentálja.

String

A "string" egy immutable típusú karaktersorozat. Indexelhető, az alsó index mindig 1. A felső index határa, és ezáltal a sztring hosszára nincs megkötés, csak annyi, hogy "int" típusú számokkal indexelhető legyen. Így tehát a leghosszabb sztring felső indexe (és mérete) "int_max".

A "string" literálok nulla vagy több karakterből álló sorozatok dupla idézőjelek közé zárva. A "string" literálon belül a nyomtatható karaktereket, és dupla idézőjelet vagy a backslash-t önmagával jelöljük. Néhány karaktert csak speciális jelölés segítségével jelölhetünk. Példák a "string" literálokra:

"" , "Item\tCost", "hello\n", "\"string\"", "'c'"

A "string" típus metódusai:

  length ( ) returns (int)
      % Visszaadja a sztring hosszát.

 
  empty ( ) returns (bool)
      % Igaz, ha  sztring hossza nulla.
 
  fetch (i: int) returns (char) signals (bounds)
      % Ha i belül van az indexhatáron, akkor az i. karaktert adja vissza, egyébként a bounds kivétel váltódik ki.

 
  rest (i: int) returns (string) signals (bounds)
      % Visszaadja az i. karakterétől kezdve a sztringet (a végéig). 
      % Bounds kivétel váltódik ki, ha az i nem érvényes index.

 
  first (i: int) returns (string) signals (bounds)
      % Visszaadja a sztring első i karakterét egy sztringbe fűzve.
      % Bounds kivétel váltódik ki, ha az i nem érvényes index.

 
  concat (s: string) returns (string) 
      % Hozzáfűzi önmagához az s sztringet.
      
% Failure kivétel kiváltódik, ha az összefűzött sztringet már nem lehet ábrázolni.
 
  append (c: char) returns (string) 
      % Önmagához fűzi a c karaktert.
      
% Failure kivétel kiváltódik, ha az összefűzött sztringet már nem lehet ábrázolni. 
      % Ezzel a metódussal megegyező hatású: self.concat(c.to_string()).
 
  extract (at: int, count: int) returns (string) signals (bounds, negative_size)
      % Ha a count negatív, akkor a negative_size kivétel váltódik ki.
      
% Ha at nem egy érvényes indexe a sztringnek, akkor a bounds kivétel váltódik ki.
      % Egyébként egy új sztringgel tér vissza, ami a következő karaktereket tartalmazza:
      
%           self[at], self[at+1], ...;
      %           min(count, self.length() - at + 1) karaktert.  
      
% Például. ha s = "abcdef", then akkor
      %             s.substr(2, 3)   = "bcd"
      
%             s.substr(2, 7)   = "bcdef"
 
  chars ( ) yields (char)
      % Visszaadja a karaktereket az elsőtől az utolsóig.
 
  lt (s: string) returns (bool)
  le (s: string) returns (bool)
  ge (s: string) returns (bool)
  gt (s: string) returns (bool)
      % Lexikografikus rendezést vesznek figyelembe a függvények, amely a karakterek ASCII kódján alapul.

 
  equal (s: string) returns (bool)
      % Igaz, ha s egyenlő önmagával.
 
  similar (s: string) returns (bool)
      % Igaz, ha s egyenlő önmagával.

 
  copy ( ) returns (string)
      % Visszaad egy ugyanolyan sztringet (tartalma: self[1],...,self[self.size()]).
 
  unparse ( ) returns (string)
      % Összefűzi azokat a sztringeket, amelyeket úgy kap, hogy minden karakterre meghívja az unparse() függvényt.


Rutinok a "string" típushoz:
  string_create (chars: sequence[char]) returns (string)
      % Visszaad egy sztringet, amely a paraméterben kapott karaktereket tartalmazza ugyanabban a sorrendben.

Array

Az "array" típus egy indexelhető, mutable típusú gyűjtemény. Ez egy paraméterezhető típus. A paraméter aktuális értéke meghatározza a tömb elemeinek típusát. Például. az array[foo] összes eleme altípusa a foo típusnak (vagy foo típusú).

Egy tömb dinamikusan tud nőni vagy csökkenni. A tömb a kezdő indexeit a létrehozáskor határozzuk meg. Ahogy a tömb nő (csökken), a hossza is nő (csökken). Az alsó határnak mindig kisebbnek (vagy egyenlőnek) kell lennie a felső határnál, kivéve ha a tömb üres. Ebben az esetben a.low=a.high+1. Minden esetben a.size=a.high-a.low+1. A tömb indexeire integer értékeket használhatunk, és a tömb hosszát is lehessen integer értékkel tárolni. Így tehát az alsó határ >= "int_min", és a felső határ <= "int_max" kell lennie.

Nézzünk egy 'a' tömböt. A megengedett indexei az összes i egész szám, amelyre igaz a.low() <= i <= a.high(). A tömb elemeit az a.low(), a.low()+1,... indexeken át lehet elérni. Ha i legális index, akkor elérhetjük az elemet az indexével a[i] módon. Például. Ha az alsó index -2, és 1,2,3 elemeket tartalmazza, akkor -2,-1,0 megengedett indexek és az a[-2], a[-1], és a[0] megengedett tömbelemek.
Az array_create tömb-rutin szolgál új tömb létrehozására (változó argumentumokat használva). Például

a: array[int] := array_create[int](0, .. 6, 9, 17)

létrehoz egy új tömb tömböt, amelynek alsó indexe 0, és a 6,9,17 elemeket tartalmazza.

Az "array[T] típus metódusai:

  empty ( ) returns (bool)
      % Igaz, ha a tömb üres, egyébként hamis.
  
  length ( ) returns (int)
      % Visszaadja a tömb hosszát (elemeinek számát).

 
  low ( ) returns (int)
      % Visszaadja az alsó indexhatárt.
 
  high ( ) returns (int)
      % Visszaadja a felső indexhatárt.

 
  fetch (i: int) returns (T) signals (bounds)
      % Ha i nem megengedett indexe a tömbnek, akkor kiváltódik a bounds kivétel,
      % egyéként az i indexű elemet adja vissza.

 
  bottom ( ) returns (T) signals (bounds)
      % Ha a tömb üres, akkor kiváltódik a bounds kivétel,
      % egyébként a tömb első elemével tér vissza.

 
  top ( ) returns (T) signals (bounds)
      % Ha a tömb üres, akkor kiváltódik a bounds kivétel,
      
% egyébként a tömb utolsó elemével tér vissza.
 
  store (i: int, v: T) signals (bounds)
      % Módosítja a tömböt.
      % Ha i nem megengedett indexe a tömbnek, akkor kiváltódik a bounds kivétel,
      
% egyébként a tömb i indexű elemének értékét v-re állítja.
 
  append (x: T) 
      % Módosítja a tömböt.
      % Amennyiben az x elemet a tömb felső részéhez hozzáillesztve a tömb felső indexe, vagy a tömb hossza túl nagy lesz,
      
% akkor kiváltódik a failure kivétel,
      % egyébként hozzáilleszti az x elemet a tömb felső részéhez.

 
  remove ( ) returns (T) signals (bounds)
      % Módosítja a tömböt.
      
% Ha a tömb üres, akkor kiváltódik a bounds kivétel,
      % egyébként kiveszi és visszaadja a tömb utolsó elemét.

 
  append_low (x: T) 
      % Módosítja a tömböt.
      % Amennyiben az x elemet a tömb alsó részéhez hozzáillesztve a tömb alsó indexe, vagy a tömb hossza túl nagy 
      % lesz, akkor kiváltódik a failure kivétel,
      
% egyébként hozzáilleszti az x elemet a tömb alsó részéhez (első eleme elé).
 
  remove_low ( ) returns (T) signals (bounds)
      % Módosítja a tömböt.
      
% Ha a tömb üres, akkor kiváltódik a bounds kivétel,
      % egyébként kiveszi és visszaadja a tömb első elemét.

 
  predict (cnt: int)
      % A metódus nincs hatással a tömb állapotára.
      % Azonban a metódus előre megmondja, hogy a tömb cnt méretűre fog nőni,
      
% és a hozzáfűző eljárások, amelyek okozzák a tömb növekedését, talán gyorsabban érvénybe lépnek, mint az előre látott
      % hívások visszatérési értéke.

 
  set_low (lb: int) 
      % Módosítja a tömböt.
      
% Ha alsó index lb-re való módosításával a tömb felső indexe, vagy a hossza túl nagy, akkor kiváltódik a failure
      % kivétel, egyébként alsó indexet lb-re állítja, és ennek megfelelően újraszámozza a tömb elemeit.
 
  trim (lb: int, count: int) signals (negative_size, bounds)
      % Módosítja a tömböt.
      
% Ha count < 0, akkor kiváltja a negative_size kivételt.  
      % Ha lb < low() vagy lb > high() + 1, akkor kiváltja a bounds kivételt,
      
% egyébként eltávolítja a tömb olyan elemeit, amelyeknek indexe kisebb mint lb, vagy nagyobb mint ls+count-1.
      % Az új alsó index lb lesz.
      
% Például, a egy array[int] típusú tömb, melynek alsó indexe 0, és 5 elemet tartalmaz (1,2,3,4,5).
      % Ekkor a a.trim(3, 2) úgy változtatja meg, hogy az alsó index 3 lesz, és a tömbnek 2 eleme lesz (4 és 5).
      
% Az a.trim(3, 12) utasításnak ugyanaz a hatása.
 
  indexes ( ) yields (int)
      % Eredményként visszaadja a megengedett indexeit a pre(tömb)-nek, az alsó indextől a felső indexig, ahol pre(tömb)
      % a tömböt jelenti a hívás pillanatában.
      
% Megjegyezzük, hogy bármilyen módosítása a tömbnek a ciklus magjában nincs hatással ennek a metódusnak az
      % integer eredményeire.

 
  elements ( ) yields (T) 
      % Az x.elemets() metódus hatása ekvivalens a következő törzzsel:
      
%                 for i: int in x.indexes() do
      %                     yield (x[i]) except when bounds: signal failure(...) end
      
%                     end
      % Így tehát ha a ciklus törzsében nincs semmi módosítás a tömbre vonatkozóan, akkor a tömb elemeit adja vissza
      
% a megfelelő sorrendben. Megjegyezzük, hogy változtatás van a ciklus törzsében, akkor az hatással lehet a
      % visszaadott értékekre.

 
  equal (a: array[T]) returns (bool)
      % Igaz, ha önmaga és a ugyanaz a tömb objektum.
 
  similar (a: array[T]) returns (bool)
        ahol T rendelkezik similar (T) returns (bool) metódussal
      % Igaz, ha önmaga és a hossza, alsó indexe, és az elemet a megfelelő sorrendben azonosak (T similar metódusát 
      % használva az összehasonlításhoz).

 
  copy ( ) returns (array[T])
        ahol T rendelkezik copy ( ) returns (T) metódus
      % Visszaad egy új tömböt, amelynek ugyanakkora a hossza, és egyezik az alsó indexe, és ugyanazokat az elemeket 
      % tartalmazza a megfelelő sorrendben (a T copy metódusát használva).

 
  unparse ( ) returns (string)
        ahol T rendelkezik unparse ( ) returns (string) metódussal
      % Visszaad egy sztringet, amelyet az elemein végrehajtott unparse metódusok segítségével hoz létre.
      
% A sztringnek a következő formája van: array[L:eL,...,eH],
      % ahol ei a tömb i indexű elemének unparse metódusának eredménye, és L az alsó, H pedig a felső indexhatára a tömbnek.
Az "array[T]" típus metódusai:
  array_new[T] ( ) returns (array[T])
      % Egy új tömböt hoz létre, melynek alsó indexe 1.
 
  array_create[T] (lb: int, els: sequence[T]) returns (array[T]) 
      % Egy új tömböt hoz létre, amelynek alsó indexe lb lesz, és az elemei az els sorozat elemei lesznek a megfelelő
      
% sorrendben.
      % A failure akkor váltódik ki, ha a felső indexe a tömbnek túl nagy lesz.

 
  array_generate[T] (lb: int, els: iter () yields (T)) returns (array[T])
      % Egy új tömböt hoz létre, amelynek alsó indexe lb lesz, és az elemeit az els iterátor hozza létre a megfelelő
      % sorrendben.
      
% A failure akkor váltódik ki, ha a felső indexe a tömbnek túl nagy lesz.

Sequence

A "sequence" típus egy immutable típusú indexelt gyűjtemény. Ez egy paraméterezhető típus, egy konkrét leírás aktuális paramétere meghatározza a sorozat elemeinek típusát. A sorozat első indexe mindig 1 lesz. A sorozat hosszát egy integer típussal tudjuk ábrázolni, ezért "int_max" lehet a maximum hossz.

A "sequence_create" sorozat rutin egy új sorozatot hoz létre (változó argumentumokat használva) Például

s: sequence[int] := sequence_create[int](.. 6, 9, 17)

létrehoz egy új sorozatot, amely a 6,9,17 elemeket tartalmazza.

A "sequence[T]" típus metódusai:

  empty ( ) returns (bool)
      % Igaz, ha a sorozat üres, egyébként hamis.
 
  length ( ) returns (int)
      % Visszaadja a sorozat hosszát (elemeinek számát).

 
  fetch (i: int) returns (T) signals (bounds)
      % Ha i nem megengedett indexe a sorozatnak, akkor kiváltódik a bounds kivétel,
      
% egyéként az i indexű elemet adja vissza.
 
  replace (i: int, v: T) returns (sequence[T]) signals (bounds)
      % Ha i nem megengedett indexe a sorozatnak, akkor kiváltódik a bounds kivétel,
      % egyébként visszaad egy új sorozatot, amely ugyanazokat az elemeket fogja tartalmazni, kivéve az i indexű elem v lesz.
 
  append (x: T) returns (sequence[T]) 
      % Visszaad egy új sorozatot, melynek végére hozzácsatolta az x elemet.
      
% A Failure kivétel akkor váltódik ki, ha a sorozat hossza túl nagy lesz.
 
  extract (at: int, count: int ) returns (sequence[T]) signals (bounds, negative_size)
      % Ha at nem egy megengedett indexe a sorozatnak, akkor kiváltódik a bounds kivétel, valamint ha count negatív,
      % akkor a negative_size kivétel. 
      
% Egyébként visszaad egy új sorozatot, amely az at indexű elemtől tartalmazza az elemeket a sorozat végéig.
      % (self[at], ..., self[min(at + count - 1, self.length())])

 
  concat (s: sequence[T]) returns (sequence[T]) 
      % Visszaad egy új sorozatot, amit úgy kap meg, hogy önmagához hozzáfűzi az s sorozat elemeit.
      
% A failure kivétel akkor váltódik ki, ha a sorozat hossza túl nagy lesz.
 
  indexes ( ) yields (int)
      % Eredményként megkapjuk a sorozat megengedett indexeit.

 
  elements ( ) yields (T) 
      % Eredményként megkapjuk a sorozat elemeit, az elsőtől az utolsóig.

  equal (s: sequence[T]) returns (bool)
        ahol T rendelkezik equal (T) returns (bool) metódussal
      % Igazat ad vissza, ha önmaga és s nem különböztethető meg, azaz megegyezik a hosszuk és az elemeik a megfelelő
      % sorrendben azonosak (az equal metódust használva).

 
  similar (s: sequence[T]) returns (bool)
        ahol T rendelkezik similar (T) returns (bool) metódussal
      % Igazat ad vissza, ha önmagára és s-re igaz, hogy a hosszuk megegyezik, és az egymásnak megfeleltetett elemek
      % megegyeznek (használva az elemek similar metódusát).

 
  copy ( ) returns (sequence[T])
        ahol T rendelkezik copy ( ) returns (T) metódussal
      % Visszaad egy új sorozatot, amelynek megegyezik a hossza önmagával, és az elemeit önmaga elemeiből a copy metódus
      % segítségével kapjuk meg ugyanabban a sorrendben.

 
  unparse ( ) returns (string)
        ahol T rendelkezik unparse ( ) returns (string) metódussal
      % Egy sztringet állit elő, amelyek az elemei unparse metódusainak segítségével állit össze.
      % A sztringnek a következő formája van: vector[e1,...,en],
      
% ahol ei az i indexű elem unparse metódusa meghívásának az eredménye.
 
A "sequence[T]" típus rutinjai:
   sequence_create[T] (els: sequence[T]) returns (sequence[T])
      % Létrehoz egy új sorozatot, ami az els elemeket tartalmazza ugyanabban a sorrendben.

   sequence_generate[T] (n: int, els: iter () yields (T)) returns (sequence[T])
      signals (negative_size, not_enough)
      % Ha n < 0, akkor kiváltódik a negative_size kivétel.  
      % Ha az iterátor által szolgáltatott eredmények száma kevesebb mint n, akkor kiváltódik a not_enough kivétel.
      
% Egyébként visszaad egy sorozatot, amely tartalmazza az eredményként kapott első n darab elemet 
      % ugyanabban a sorrendben.

Vector

A "vector" típus egy fixméretű, mutable típusú, homogén gyűjtemény, melynek alsó indexe 1. A vector[T] összes elemének kezdeti értékét beállítjuk néhány T típusú elem segítségével. A vektor hosszát integer értékkel reprezentáljuk, így a hossza maximum "int_max" lehet.

A "vector_create" vektor rutin egy új vektort hoz létre a megfelelő formában (változó argumentumokat használva). Például

v: vector[int] := vector_create[int](.. 6, 9, 17)

létrehoz egy 6,9,17 elemeket tartalmazó vektort.

A "vektor" típus metódusai:

  length ( ) returns (int)
      % Visszaadja a vektor hosszát (elemeinek számát).

 
  fetch (i: int) returns (T) signals (bounds)
      % Ha i nem megengedett indexe a vektornak, akkor kiváltódik a bounds kivétel,
      
% egyéként az i indexű elemet adja vissza.
 
  store (i: int, v: T) signals (bounds)
      % Módosítja a tömböt.
      
% Ha i nem megengedett indexe a vektornak, akkor kiváltódik a bounds kivétel,
      % egyébként a vektor i indexű elemének értékét v-re állítja.

 
  indexes ( ) yields (int)
      % Eredményként visszaadja a vektor megengedett indexeit.
 
  elements ( ) yields (T) 
      % Az x.elemets() metódus hatása ekvivalens a következő törzzsel:
      
%             for i: int in x.indexes() do yield(x[i]) end
      % Megjegyezzük, hogy változtatás van a ciklus törzsében, akkor az hatással lehet a visszaadott értékekre.
 
  equal (v: vector[T]) returns (bool)
      % Igaz, ha önmaga és a ugyanaz a vektor objektum.

 
  similar (v: vector[T]) returns (bool)
        ahol T rendelkezik similar (T) returns (bool) metódussal
      % Igaz, ha önmaga és v hossza, és az elemek a megfelelő sorrendben azonosak (T similar metódusát 
      % használva az összehasonlításhoz).

 
  copy ( ) returns (vector[T])
        ahol T rendelkezik copy ( ) returns (T) metódussal
      % Visszaad egy új vektort, amelynek ugyanakkora a hossza, és ugyanazokat az elemeket 
      
% tartalmazza a megfelelő sorrendben (a T copy metódusát használva).

  unparse ( ) returns (string)
        ahol T rendelkezik unparse ( ) returns (string) metódussal
      % Visszaad egy sztringet, amelyet az elemein végrehajtott unparse metódusok segítségével hoz létre.
      
% A sztringnek a következő formája van: vector[e1,...,en],
      % ahol ei a vektor i indexű elemének unparse metódusának eredménye.
A "vector[T]" típus rutinjai
  vector_fill[T] (count: int, elem: T) returns (vector[T]) signals (negative_size)
      % Visszaad egy új vektort, amely count db 'elem' értékkel rendelkező elemet tartalmaz.
      % Ha count negatív, akkor kiváltódik a negative_size kivétel.

 
  vector_create[T] (els: sequence[T]) returns (vector[T])
      % Visszaad egy új vektort, amely az 'els' sorozat elemeit tartalmazza ugyanabban a sorrendben.
 
  vector_generate[T] (n: int, els: iter () yields (T)) returns (vector[T])
      signals (negative_size, not_enough)
      % Ha n < 0, akkor kiváltódik a negative_size kivétel.  
      
% Ha az iterátor kevesebb mint n elemet ad eredményül, akkor kiváltódik a not_enough kivétel.  
      % Egyébként egy új vektort ad vissza, amely az iterátor által szolgáltatott első n elemet tartalmazza
      
% ugyanabban a sorrendben.

Record

A "record" típus mezők halmazát tartalmazó mutable típus. A "record" típus példányosításakor meg kell adni a rekord objektumainak mezőnevét és típusát. Legalább egy mezőnek lennie kell, és minden mezőnév különböző kell hogy legyen. A mezőnevekben a kis és nagybetűk között nem teszünk különbséget. Minden rekord típushoz létezik egy rekord konstruktor, amit a típus új rekordjainak létrehozására használhatunk. Minden rekord rendelkezik két metódussal minden mezőjére, amelyekkel megengedjük a felhasználónak hogy lekérdezze illetve módosítsa a mező tartalmát. Egy "A" nevű mezőre ezek a metódusok "A" és "set_A". Itt egy példa:

rt = record[a: int, b: real] % egy rekord típus
x: rt % x egy ilyen rekord típus objektumára fog mutatni.
x := rt{a: 3, b: 1.1} % az objektum (konstuktorral való) létrehozása
i: int := x.a( ) % olvassa az "a" komponenst
x.set_b(1.7) % módosítja a "b" komponenst

Egy meghatározott rekord típus típus-egyenlőségénél a mezők neve és típusa lényeges, és a mezők sorrendje is fontos.

Az "rt" rekord típus a következő metódusokkal rendelkezik. ("st" egy a rekorddal megegyező "struct" típus, vagyis megegyezik a mezőneveinek sorrendje és típusa, valamint a mezők sorrendje is)

A "rt" rekord típus metódusai:

  a ( ) returns (T)
      % (Itt a egy mező neve, és T a neki megfelelő típus)
      
% Visszaadja az objektum a mezőjében tárolt értéket.
 
  set_a (x: T)
      % (Itt a egy mező neve, és T a neki megfelelő típus)
      % Módosítja a rekordot.
      
% Eltárolja x-et az objektum a mezőjében.
 
  r_gets_r (x: rt)
      % Módosítja a rekordot.
      % Módosítja az objektum mezőit az x megfelelő mezőivel.

 
  r_gets_s (x: st)
      % Módosítja a rekordot.
      % Módosítja az objektum mezőit az x megfelelő mezőivel.

 
  to_s ( ) returns (st)
      % Visszaad egy st objektumot, amely tartalmazza a rekord mezőinek értékét.

 
  equal (x: rt) returns (bool)
      % Igaz, ha önmaga és x ugyanaz az objektum.
 
  similar (x: rt) returns (bool)
        ahol rt összes T mezőtípusa rendelkezik similar(T) returns (bool) metódussal
      % Igaz, ha önmaga és x összes egymásnak megfeleltetett mezője megegyezik
      % (a T similar metódusát használva egy mezőre), egyébként hamis.

 
  copy ( ) returns (rt)
        ahol rt összes T mezőtípusa rendelkezik copy ( )  returns (T) metódussal
      % Visszaad egy új rekordot, melynek mezői önmaga megfelelő mező-objektumainak másolatai
      % (az objektumok copy metódusának használatával).

 
  unparse ( ) returns (string)
        ahol rt összes T mezőtípusa rendelkezik unparse ( ) returns (string) metódussal
      % Visszaad egy sztringet, amelynek a következő formája van:
      % record{n1:f1,...nn:fn}, 
      
% ahol ni az i-edik mező neve, és fi a megfelelő mező objektumának unparse metódushívásának.

Struct

A "struct" típus egy immutable rekord. Mint a "record" típusnál, itt is metódusokkal olvashatjuk a "struct" mezőit. Struktúrát létrehozhatunk konstruktorok használatával. Ezeknek a konstruktoroknak a használata megegyezik a rekordnál leírttal.

Egy "st" "struct" típusú változó a következő metódusokkal rendelkezik. ("rt" egy a rekorddal megegyező "record" típus, vagyis megegyezik a mezőneveinek sorrendje és típusa, valamint a mezők sorrendje is)

A "struct" típus metódusai:

  a ( ) returns (T)
      % (Itt a egy mező neve, és T a neki megfelelő típus)
      % Visszaadja az objektum a mezőjében tárolt értéket.

 
  replace_a (x: T) returns (st)
      % Visszaad egy új struktúrát, amely önmaga objektumát tartalmazza, kivéve hogy az a mezőnek x értéket.

 
  to_r ( ) returns (rt)
      % Visszaad egy rekordot, amelynek mezői a struktúrának megfelelő mező objektumait tartalmazzák.
 
  equal (x: st) returns (bool)
        ahol st összes T mezőtípusa rendelkezik equal (T) returns (bool) metódussal
      % Igaz, ha önmaga és x páronként megegyeznek (a mezők equal metódusát használva), egyébként hamis.

 
  similar (x: st) returns (bool)
        ahol st összes T mezőtípusa rendelkezik similar (T) returns (bool) metódussal
      % Igaz, ha önmaga és x páronként azonosak (a mezők similar metódusát használva), egyébként hamis.

 
  copy ( ) returns (st)
        ahol st összes T mezőtípusa rendelkezik copy ( ) returns (T) metódussal
      % Visszaad egy új struktúrát, melynek mezői önmaga megfelelő mező-objektumainak másolatai
      % (az objektumok copy metódusának használatával).

 
  unparse ( ) returns (string)
        ahol st összes T mezőtípusa rendelkezik unparse ( ) returns (string) metódussal
      % Visszaad egy sztringet, amelynek a következő formája van:
      % struct{n1:f1,...nn:fn}, 
      
% ahol ni a struktúra i-edik mezőjének neve, és fi a megfelelő mező objektumának unparse metódushívásának.

Oneof

A "oneof" típus egy immutable típusú (megjelölt) objektumok. A "oneof" típus egy példányosítása (konkretizálása) során meghatározunk a "oneof" objektum minden lehetséges tagokhoz nevet és a hozzárendelt típust. Legalább egy tagnak lennie kell, és a tagok neveinek különbözőnek kell lennie. A típus minden objektuma rendelkezik ezen tagok, részek közül eggyel, és az értéke a hozzárendelt típus egy értéke. Léteznek metódusok, amelyek meghatározzák a "oneof" objektumok részét és értékét, de általában a "oneof" objektumok a tagcase utasítás segítségével bontjuk fel.

"oneof" objektumokat konstruktorok segítségével hozzuk létre. Minden "oneof" típushoz konstruktorok halmazai társulnak, minden taghoz, részhez egy. Itt van néhány példa:

ot = oneof[some: int, none: null] % egy"oneof" típus
x: ot % az x változó ezen típus egyik objektumára mutat
x := ot{none: nil} % egy objektum létrehozása a none taggal
if x.is_none( ) then % a tag ellenőrzése
x := ot{some: 7} % egy objektum létrehozása a some taggal
end

tagcase x % a tagcase utasítás használatával választjuk szét az eseteket
when none: ...
when some(y: int): ...
end

Az "ot" "oneof" típus metódusai:

  is_a ( ) returns (bool)
      % (Itt a egy tag neve, és T a neki megfelelő típus)
      
% Igazat ad vissza, ha az objektum mezője a, egyébként hamisat.
 
  value_a ( ) returns (T) signals (wrong_tag)
      % (Itt a egy tag neve, és T a neki megfelelő típus)
      % Ha az objektum mezője a, akkor visszatér a mezőnek megfelelő objektummal, egyébként a wrong_tag kivételt váltja ki.
 
  equal (x: ot) returns (bool)
        ahol összes T mezőtípus rendelkezik equal (T) returns (bool) metódussal
      % Igazat ad vissza, ha önmaga és x ugyanazzal a mezővel és értékkel rendelkezik
      
% (az értékazonosság eldöntéshez az értékekre meghívjuk az equal metódusokat).

 
  similar (x: ot) returns (bool) 
        ahol összes T mezőtípus rendelkezik similar (T) returns (bool) metódussal
      % Igazat ad vissza, ha önmaga és x megegyező (hasonló) mezővel és értékkel rendelkezik
      
% (az egyezőség (hasonlóság) eldöntéshez az értékekre meghívjuk a similar metódusokat).
    
  copy ( ) returns (ot)
        ahol összes T mezőtípus rendelkezik copy ( ) returns (T) metódussal
      % Visszatér egy új "oneof" objektummal, ugyanazzal a mezővel mint amivel önmaga rendelkezik, és az értéke önmaga
      % értékének másolata (használva az érték copy metódusát).

 
  unparse ( ) returns (string)
        ahol összes T mezőtípus rendelkezik unparse ( ) returns (string) metódussal
      % Visszaad egy sztringet, amelyet a mező és a mező értékének segítségével hoz létre.
      
% A sztringnek a következő formája van: oneof[t: v],
      % ahol t a szöveges megfelelője a jelenlegi mezőnek, és v az érték unparse metódusának eredménye.

Maybe

A "maybe" típusok csaknem olyan mint a "oneof" típus, még kényelmesebb a szintaxisa, és hatékonyabb implementációk is megvalósíthatók vele. "maybe[T] = oneof[empty: null, full: T]". A "maybe" típus metódusai és rutinjai pontosan úgy vannak definiálva mint a "oneof" típusnál.

A Theta programozási nyelv

Beépített és paraméterezett típusok

Any