A Fortress programozási nyelv

Típusok, típuskonstrukciók

Típusszerkezet

A Fortress típusrendszere egyszerre támogatja név szerinti, illetve struktúrális típusokat, illetve struktúrális típusok kombinációját.
Minden kifejezésnek van egy statikus típusa, és minden értéknek van egy futásideju típusa (dinamikus típus). Néha kifejezés esetén is megemlítjük annak a típusát, ám ekkor arra a típusra gondolunk, amire a kifejezés kiértékelodik.
A nyelv a következő típusokat támogatja:

A a függvénytípusok és a BottomType nem elsőrendu típusok: nem használhatóak a programban. Bizonyos kifejezések azonban ilyen típussal rendelkeznek, és a throw illetve az exit kifejezések típusa BottomType.
Két fajta relációt definiálhatunk a típusokon: altípusosság és kizárás.
Az altípusosság egy parciális rendezés a típusokon, ami definiálja a típushierarchiát. Az őstípus az Any,
minden típus ennek az altípusa, míg BottomType a típushieararchia legalja: minden típus a BottomType őstípusa.

A kizárás reláció egy szimmetrikus reláció két típuson értelmezve, amelyeknek a metszete BottomType. Mivel a
BottomType nem elérhető (azaz semmilyen érték nem ilyen típusú), így az olyan típusok, amik kizárják egymást,
diszjunkat: nem létezhet olyan érték, aminek van két olyan őstípusa, ami kizárja egymást.

Trait típusok

A trait típus nem más, mint egy olyan nevesített típus, amit vagy egy trait, vagy egy objektumdeklaráció ad meg.
A trait-típus minden olyan típusnak az altípusa, ami az extends kifejezés után áll a deklarációjakor, illetve
minden trait típus az Any altípusa.
Trait deklarációjakor szerepelhet az excludes kulcsszó is, ami azt mondja meg, hogy az adott típus milyen más
típusokat zár ki.
Minden trait típus kizár minden nyíl, illetve N-es típust, illetve két speciális típust: a BottomType -ot, és a ()-t.

N-es típusok

Szintaxis:
    TupleType	::=	( Type, TypeList )
    TypeList	::=	Type(, Type)*
Az N-es típus egy zárójelezett, vesszőkkel elválasztott típusfelsorolásból áll.

Nyíl típusok

Szintaxis:
    Type	::=	ArgType -> Type Throws?
    ArgType	::=	( (Type , )* Type ...)
		|	TupleType
Az olyan kifejezések statikus típusa, amelyek függvénytípusra értékelődnek ki.

Függvény típusok

A függvénytípusúak a függvényértékek futás idejű típusai. A nyíl-típustól csak azért
különböztetjük meg, hogy a túlterhelt eseteket is kezeljük. Egy függvénytípus nyíl-típusok
véges halmazából áll, azonban nem minden részhalmaza a nyíl-típusoknak jólformált függvénytípus.

Egy F függvénytípus jólformált, ha minden (S1, S2) diszjunkt nyíltípusra F-en belül a következő
tulajdonságok teljesülnek:

Csak a jólformált függvénytípusokkal foglalkozunk.
Az F függvénytípus alkalmazható az A típusra, ha bármelyik résznyíltípusa alkalmazható A -ra.
Ugyanez igaz a kiértékelés során létrejövő érték-típusokra is.

Speciális típusok

Három speciális típus létezik a nyelvben: az Any, a BottomType és a (). Az Any az ősosztálya minden típusnak. Az egyetlen
típus, amit kizár, az a BottomType.
A () típus értéke (). Az egyetlen őstípusa (magán kívűl) az Any, és minden más típust kizár.
A típushierarchia legalján a BottomType áll, de a Fortressben semmilyen értéknek nem lehet ez a futásidejű típusa; az exit
és a throw kifejezéseknek ez a statikus típusa. A BottomType minden típus altípusa, és minden mást típust kizár (önmagát is).

Elemi típusok

Diszkrét típusok

A nyelv beépített típusként támogatja a matematikából megismert egész számokat: Ez a ZZ32 (Int), illetve ZZ64 beépített típus, attól függően, hogy hány biten szeretnénk ábrázolni. Mindkét típus altípusa az Integral típusnak.

Valós típusok

A nyelv beépített típusként támogatja a racionális számokat, 64 biten ábrázolva. Ez az RR64 típus. A nyelv továbbá támogatja az összefoglaló Number típust.

Mutató- és referenciatípusok

A Mutató és referencia típusok nem szerepelnek a nyelvi elemek között, ezekre nincs lehetőség Fortressben.

Típuskonstrukciók

Tömb típus

A nyelv támogatja tetszőleges típusból a tömbkészítést, úgy, hogy felsoroljuk az elemeket.
Példák:

a:ZZ32[5] = [0 1 2 3 4] b:ZZ32[2,2] = [3 4 5 6] c:ZZ32[2,2,3] = [1 2 3 4;;5 6 7 8;;9 10 11 12] d:RR64[2,2] = [(cos phi)(-sin phi) (sin phi)(cos phi)]

Magasabb dimenziójű tömb deklarálásra is lehetőség van. Négy dimenziónál az elválasztó 3 pontosvessző, ötdimenziósnál 4, és így tovább. Vektorok ugyanúgy definiálhatóak, ahogy az egydimenziós tömbök, mátrixok pedig úgy, mint a többdimenziósok.

Asszociatív tömb típus

m = {"a" -> 0, "b" -> 1, "c" -> 2}

Únió-típus

A nyelv nem támogatja.

Halmaz típus

A halmaz elemeit kapcsos zárójelek között fel kell sorolni, például:

s = {0,1,2,3,4}
Másik lehetőség egy halmaz/lista/tároló elemeinek a leírására ha megadunk egy szabályt,
ami ezekre érvényes. Ilyenkor ezen elemek meghatározása párhuzamosan történik. (Comprehensions).
t = {1,2,3,4,5,6,7,8} s = {x/2 | x <- t} u = {x + y | x <- s, y <- t} v = {x | x <- t, x >= 0}
A nyelv támogatja továbbá szummák és produktumok felhasználást is:
szumma(n) = SUM[i <- 1:n] i factorial(n) = PROD(i <- 1:n] i