'AI/Lang' kézikönyv

DocVerzió: 0.2 (2021.07.25.)

Ez az új nyelv a hagyományos szoftverfejlesztési szemlélet, a tudásábrázolás és a gépi feldolgozás támogatására készült. Erősen épít az absztakcióra és a transzformációra.

Opcionálisan multipragmadigma és erős típusos: a nyelv képességei egyedileg korlátozhatóak, validálhatóak. Ontológiai adatokkal kiegészítve tág határok között finomhangolható.

A teljesen nyílt architektúra rendkívüli flexibilitást biztosít. Szabadon konfigurálható az összes rendszerelem:

Célok:

Szintaxis

Megjegyzések

Három típus érhető el:

Kulcsszavak

Mivel a szintaxis sem végleges, átmenetileg egy csillaggal (*) kezdődnek a kulcsszavak.

Számformátumok

A jelöletlen egész szám alapértelmezésben int32 típust kap, a lebegőpointos float32 típust. A következő utótagok típusai:

Sztringek

A sztringek csak kódolt speciális jeleket tartalmazhatnak, nyers sor vége jelet nem. Az egymás után következő sztringek összefűzésre kerülnek.

Logikai értékek

Három logikai érték támogatott: true, false, undefined.

Literálok

A sima kapcsos zárójel vektor típust jelöl. Specializált tárolókhoz csak homogén tartalom rendelhető.

Változók

A numerikus változó dollár jellel ($) kezdődik és egy egész szám követi, a nevesített változó karakterláncot tartalmaz a dollár után. Behelyettesítsékor használatosak.

Nyers szöveg

Nyers szövegrésztet a %{ és }% jelek között adható meg, a közbenső rész nem lesz külön értelmezve.

Speciális elemek

Típusok

Típuscsoportok

Adat típusok

A nyers adatokon csak alapműveletek és hozzárendelés végezhető, a hozzátartozó csómópontok teljes értékűek:

Teljes értékű változatuk Data:: prefixet kapott és nagybetűvel kezdődik a neve (Data::String).

Tároló típusok

Speciális csomópontok, tartalmuk metódusokkal és belső navigációs hívásokkal érhető el. Általános tárolók: Vector, List, Map, Pair, Set. Két küllönleges tároló van, Container a típusdeklarációkhoz, a Single egy elem tárolásához. Meg kellett különböztetni a változóktól, itt a kapcsolat laza, szabadon törölhető és hozzáadható. Tartalmazhatnak adatot, és példányosított típust is. Nevük kötelezően Store:: prefixszel kezdődik.

Műveletek

Aritmetikai műveletek nyers adatok vagy adat csomópontok között történhet. Az operátor metódus még nem támogatott.

Alapműveletek

Konstans lista

Rögzített tartalmú tömb, sztring összehasonlításra használható. A Set tároló csomópontokat tartalmaz, a konstans lista nyers adatokkal dolgozik, ezért sokkal hatékonyabb. Negálni a ! *in formával lehetséges.

*if (value *in <("a", "b", "c")>) {
    System::stdout ("Match!\n");
}

Ciklusok

Léptető 'for' ciklus:

*for (int32 i = 0; i < 10; i++) {
    System::stdout ("%1\n"[i]);
}

'Foreach' ciklus:

Store::Vector<Data::String> list = {"a", "b", "c"};
*foreach (Data::String i *in list) {
    System::stdout ("%1\n"[i]);
}

Elöltesztelő 'while' ciklus:

uint32 i = 0;
*while (i < 10) {
    System::stdout ("%1\n"[i++]);
}

Hátultesztelő 'until' ciklus:

uint32 i = 0;
*do {
    System::stdout ("%1\n"[i++]);
}
*until (i < 10);

Kondíciók

Feltétel:

*if (value == "a") {
    System::stdout ("1\n");
}
*elsif (value == "b") {
    System::stdout ("2\n");
}
*else {
    System::stdout ("3\n");
}

'Switch':

Egész típus (int32) és sztring is megadható kulcsnak, de nem keverhető.

string a = "a";
*switch (a) {
    *case "a": {
        System::stdout ("1\n");
    }
    *case "b":
    *case "c": {
        System::stdout ("2\n");
    }
    *default: {
        System::stdout ("3\n");
    }
}

Belépési pont és funkció

A funkciók egyszerű sorrendi végrehajtást lehetővé tevő szerkezetek. A belépési pont végrehajtása megegyezik a funkcióéval, szemantikai jelentősége van. Visszatérése után minden művelet befejezettnek tekinthető és minden erőforrásnak lezárásra kell kerülnie.

*function bool hello (Data::String message) {
    *if (message.empty())
        *return false;
    System::stdout (message);
    *return true;
};

Belépési pont paramétere

Lehet üres paraméter vagy sztring tömb. A konkrét típus a hívás módjától és a felhasználástól függ. Konzolból is futtaható, de egy cél nyelvre (pl. C++ vagy Python) transzformált állapotban van konkrét jelentősége.

*entrypoint int main (Store::Vector<Data::String> args) {
    System::stdout ("Hello from %1\n"[args[0]]);
    *return 0;
};

Osztály és metódus

Csómópontok

A nyelv apró építőkövei. Az egységes felépítés megvalósításához szinte minden belőlük épül fel. Tartalmazhatnak nyers adatot, más csomópontokat, lehet nevük, vannak egységes meta metódusaik. Ezek a következők lehetnek:

Adatként használva minden csomópont tartalmaz saját nevet, attribútumot, azonosítót, raktár hivatkozást, és referencia számlálót. Ekkor minden csomópont egy objektumnak számít. Példányosított összetett típusoknál több csomópont alkot egy objektumot, ekkor közösen ösztoznak a felsorolt tulajdonságokon. Tárolás szempontjából nem ideális, de a keresést és a transzformációt nagyban megkönnyíti.

Öroklés

Osztályoknál és a rá épülő típusoknál többszörös öröklés lehetséges, az alaposztályok külön csomópontok. Példányosításkor a közös adatokat tároló elem jön létre, ezek:

Transzformációnál összeolvadás történik, kivéve az osztály típusokat.

Attribútumok

Minden csomópont tartalmazhat egyedi attribútumot. Előtag és érték opcionális, utóbbi az alábbi lehet:

Jelenleg az aritmetikai műveletek kivételek, csak csoportos attribútum adható meg:

[std:mathMode="saturating"] a = b + c;

Osztály jellegű típusok

Jellemzőjük a többszörös öröklés, virtuális metódusok, véglegesített tagváltozók. Típusai:

Absztakt osztály

A normál osztály elemein felül tartalmazhat ontológiai definíciókat, transformációs és kiegészítő adatokat. Átmeneti változat a futásidejű OO osztály és az ontológiai osztály között. Nem példányosítható közvetlenül, csak OO osztállyá alakítva. DSL elemet is tartalmazhat, amit akár futtatható metódussá lehet transzformálni. A nevében megadható egy megkülönböztető '#' karakter, amivel különbséget lehet tenni az absztakt és a belőle létrehozott végrehajtható osztály között.

*representation #Thing {
    Data::String value;
    *metadata std:memberOf #Group;
    *method restoreValue ();
};

Adathalmaz

A Json-hoz hasonló felépítéssel lehet típust adattal feltölteni (átdolgozásra szorul).

<<{ [attr] Type;
   member1: value1;
   group: {
       member2: value2;
   }
}>>

Tárolók

Kulcs/érték alapon adatokat lehet tárolni bennük. Lehetnek nyílt (osztott) elérésüek. Célok:

Transzformáció

Validációs/adatgyűjtő, A->A és A->B típus is megvalósítható. Az egyes elemekre kulcs és minta találati szabályokat lehet létrehozni.

Beolvasók (parser)

Szöveges adatokból szintaxis fát (AST) hoz létre.

Beépített beolvasók:

Erőforrások

Átmenetet képez az értékkel feltöltés és az ontológiai tények között. Használatával például kereshető módon globális adatokat (konstansokat) lehet megadni, projekt (vagy csomag) publikus adatokat megosztani, adatokat és adatbázisokat leírni, ontológiai állítmányt és funkciókat/metódusokat összekötni.

*representation #ResourceType {
    Data::String name;
    Data::String url;
    *metadata url <std:instanceOf> <inet:Location>;
};
*resource HUP: #ResourceType {
    name: "HUP";
    url: "https://hup.hu";
};

Lekérdezés

Lekérdezéseket szabadon lehet megvalósítani, de az egyszerűség kedvéért projektekhez és raktárakoz egy pici bővítés készült. A *query definíciók automatikusan metódusokká transzformálódnak. Keresési feltételek bővíthetőek.

*class TestQuery {
    *method bool testNot5 (Node value) {
        *if (value.@type != "Data::Int32")
            *return false;
        *return *cast<Data::Int32>(value) != 5;
    };
    *query query1 (System::Repository repository) {
        *for a
            *where
                testNot5(a)
            *return "0" + a.@string;
    };
};

Névterek és munkaterek

Névterek: a többi programozási nyelvhez hasonlóan nagyobb névcsoportokat lehet létrehozni.

Munkaterek: speciális névtér, lényegében a névterek altereit jelölik valamilyen szempont alapján szétválasztva. Verzió információt is tartalmazhat (Például DB::InterNet::HTML:{html5-1.1}:).

Szintaxis:

*namespace DB::InterNet::HTML;
*workspace html5;
*version 1.1;

Vagy meta információkkal:

*workspace DB::InterNet::HTML:{html5-1.1}: {
    *metadata <workspaceKind> <specificationImplementation>;
    *metadata <specificationGroup> "HTML";
    *metadata <majorVersion> "5";
};

Csoportosítás

Amennyiben több nevesített elemre szeretnénk hivatkozni, az *unit nyújt rá nyelvi lehetőséget. Ekkor minden elem megkapja előtagként a csoport nevét. Nevesített csoportban csak egyben és csak egyszer szerepelhet benne minden elem, névtelen (kódba beágyazott) példányoknál nincs megkötés.

*unit Group1 {
    *class Class1 {};
    *class Class2 {};
};

Összetett csoportosítások attribútumok, vagy tripletek segítségével lehetséges.

Szemantikus elemek

Metadata

Segítségével ontológiai állítmányt és értéket lehet rendelni tárólókhoz, absztakt oszrályokhoz, erőforrásokhoz. Ha az alany nincs megadva, akkor a definíciót tartalmazó csomópontra vonatkozik.

*metadata TypeName <std::predicate> "value";

Hármasok (triplets)

Névvel ellátott értékhármasok gyűjteménye. Lekérdezett, különálló vagy külső információtöredéket tartalmaz. Összefűzésükkel ontológiai szótárak hozhatók létre.

*triplets Group1 {
    type1 <std::predicate1> "value1";
    type2 <std::predicate2> "value2";
    type2 <std::predicate3> type1;
};

Adatforrások

Ontológiai szótárak épitéséhez három út vezethet:

Projektek

Valamilyen szempontból elkülöníthető kódot és adatokat nagyobb csoportba, projektekbe lehet szervezni. Kihagyható, de erősen ajánlott.

Kötelező elemei:

Manifest

Szabványos Json vagy XML fájl, ami a projekt/csomag alap- és betöltési adatait tartalmazza:

Project osztály

Speciális osztály, egy projekt egy példányt tartalmazhat. Elemei:

A projekt betöltésekor először a manifest fájl alapján betöltődnek a szükséges elemek, létrejön egy a projekt nevét tartalmazó publikus raktár és környezet kontextus. A futtatókörnyezet eltárolja a példányosított osztállyt és opcionálisan meghívja az onLoad() metódust, amennyiben létezik. Ha adatlekérés céljából jön létre egy példány a projekt osztályból, a konstruktor végrehajtódik, de az onLoad() nem. Emiatt megfelelően kell elosztani az inicializációs hívásokat. Bezáráskor az onClose() és a destruktor kerül végrehajtásra.

Az eltérő projekt típusok miatt opcionális az onSave(), végrehajtása környezetfüggő, bezáráskor nem kerül meghívásra (ellentétben az onClose() metódussal).

Erőforrások

A projekt osztály önmaga is egy csoportosítás, az ebben elhelyezett erőforrásoknak ezzel korlázozott lesz a hatóköre. Amennyiben szükséges, a manifest fájl is tartalmazhat bejegyzést osztott erőforrások megadásához.

Projekt célok

Speciális erőforrások és metódusok segítségével projekt célok definiálhatók, fájlok vagy adatbázis elemek létrehozásához.

Interaktív parancssorból, parancsszkriptből vagy weboldalon lekérdezhetők és végrehajthatók. Használatuk vizualizációhoz és dokumentációhoz is nagyon előnyös.

Csomagok

A projektek létrehozhatnak egy vagy több csomagot, amik osztott adatoknak vagy osztott könyvtárnak felelnek meg. Felépítése a projektekhez hasonló, de tartalmaznak speciális elemeket. Tartalmuk egy része a raktárakba importálható.

Különbségek:

Tennivalók