Egy adott paraméter pozíción értelmes tömör Prolog kifejezések halmaza. Prologban általában nincs típushiba, a hiba hatására a hívás meghiúsul.

Hasonló dokumentumok
FUNKCIONÁLIS PROGRAMOZÁS

S0-02 Típusmodellek (Programozás elmélet)

Generikus Típusok, Kollekciók

Alapok. tisztán funkcionális nyelv, minden függvény (a konstansok is) nincsenek hagyományos változók, az első értékadás után nem módosíthatók

Bevezetés a programozásba II. 5. Előadás: Másoló konstruktor, túlterhelés, operátorok

Programozási nyelvek Java

Programozás II. 2. Dr. Iványi Péter

Bevezetés a programozásba Előadás: Tagfüggvények, osztály, objektum

2019, Funkcionális programozás. 2. el adás. MÁRTON Gyöngyvér

Programozási nyelvek Java

Funkcionális és logikai programozás. { Márton Gyöngyvér, 2012} { Sapientia, Erdélyi Magyar Tudományegyetem }

A függvény kód szekvenciáját kapcsos zárójelek közt definiáljuk, a { } -ek közti részt a Bash héj kód blokknak (code block) nevezi.

file./script.sh > Bourne-Again shell script text executable << tartalmat néz >>

Web-technológia PHP-vel

XPath. dr. Paller Gábor. XML technológiák

Logika nyelvészeknek, 12. óra A típuselmélet alapjai. Lehetőség van a kvantorfogalom mellett a funktorfogalom általánosítására is.

2018, Funkcionális programozás

C# Nyelvi Elemei. Tóth Zsolt. Miskolci Egyetem. Tóth Zsolt (Miskolci Egyetem) C# Nyelvi Elemei / 18

Imperatív programozás

A C programozási nyelv I. Bevezetés

Visszalépéses keresés számintervallum felsorolása

7. Laboratóriumi gyakorlat: Vezérlési szerkezetek II.

Programozás alapjai. 5. előadás

1. Egyszerű (primitív) típusok. 2. Referencia típusok

Programok értelmezése

7. fejezet: Mutatók és tömbök

Járműfedélzeti rendszerek II. 3. előadás Dr. Bécsi Tamás

Miután létrehoztuk, szeretnénk neki beszédesebb nevet adni. A név változtatásához a következőt kell tenni:

The modular mitmót system. DPY kijelző kártya C API

Programozás C++ -ban 2007/7

Oktatási segédlet 2014

A C programozási nyelv I. Bevezetés

1. Template (sablon) 1.1. Függvénysablon Függvénysablon példányosítás Osztálysablon

Válogatott fejezetek a logikai programozásból ASP. Answer Set Programming Kelemen Attila

A C# programozási nyelv alapjai

Szkriptnyelvek. 1. UNIX shell

Programozás C és C++ -ban

Java és web programozás

Memóriagazdálkodás. Kódgenerálás. Kódoptimalizálás

Programozás C++ -ban 2007/1

Egy Erlang refaktor lépés: Függvényparaméterek összevonása tuple-ba

Szövegek C++ -ban, a string osztály

Apple Swift kurzus 3. gyakorlat

Programozás burritokkal

Python tanfolyam Python bevezető I. rész

Java és web programozás

Programozási nyelvek Java

Gyártórendszerek modellezése: MILP modell PNS feladatokhoz

Kifejezések. Kozsik Tamás. December 11, 2016

Operációs Rendszerek II. labor. 2. alkalom

Algoritmizálás és adatmodellezés tanítása 1. előadás

Függvény pointer. Feladat: Egy tömbben soroljunk fel függvényeket, és hívjuk meg valahányszor.

A C++ szigorúbban kezeli a típuseltéréseket, mint a C nyelv Lehetséges típuskonverziók:

Programozás C++ -ban

Funkcionális Nyelvek 2 (MSc)

Máté: Assembly programozás

Bevezetés a programozásba. 9. Előadás: Rekordok

Bevezetés a programozásba. 8. Előadás: Függvények 2.

Tulajdonságalapú tesztelés

Adatbázisok* tulajdonságai

Komputeralgebra rendszerek

2019, Funkcionális programozás. 5. el adás. MÁRTON Gyöngyvér

van neve lehetnek bemeneti paraméterei (argumentumai) lehet visszatérési értéke a függvényt úgy használjuk, hogy meghívjuk

Komputeralgebra rendszerek

Forráskód formázási szabályok

FUNKCIONÁLIS PROGRAMOZÁS ELŐADÁS JEGYZET

Elsőrendű logika szintaktikája és szemantikája. Logika (3. gyakorlat) 0-adrendű szemantika 2009/10 II. félév 1 / 1

Az osztályok csomagokba vannak rendezve, minden csomag tetszőleges. Könyvtárhierarhiát fed: Pl.: java/util/scanner.java

Írjon olyan programot a standard könyvtár alkalmazásával, amely konzolról megadott valós adatokból meghatározza és kiírja a minimális értékűt!

Objective-C PPKE-ITK

1. Példa. A gamma függvény és a Fubini-tétel.

Programozási nyelvek (ADA)

Programozás C++ -ban

Programozás I. 3. gyakorlat. Szegedi Tudományegyetem Természettudományi és Informatikai Kar

2018, Funkcionális programozás

Programozás. (GKxB_INTM021) Dr. Hatwágner F. Miklós május 6. Széchenyi István Egyetem, Gy r

C++ referencia. Izsó Tamás február 17. A C++ nyelvben nagyon sok félreértés van a referenciával kapcsolatban. A Legyakoribb hibák:

Programozás C- és Matlab nyelven C programozás kurzus BMEKOKAM603 Függvények. Dr. Bécsi Tamás 6. Előadás

2016, Funkcionális programozás

JUnit. JUnit használata. IDE támogatás. Parancssori használat. Teszt készítése. Teszt készítése

Adattípusok, vezérlési szerkezetek. Informatika Szabó Adrienn szeptember 14.

Adatbázisrendszerek. adatbázisokban. Objektumorientált és objektum-relációs adatbázisok április 24.

Rekurzió. Dr. Iványi Péter

OOP #14 (referencia-elv)

Debreceni Egyetem Matematikai és Informatikai Intézet. 13. Védelem

Java II. I A Java programozási nyelv alapelemei

FUNKCIONÁLIS PROGRAMOZÁS GYAKORLAT JEGYZET

malloc free malloc free int sum(int a[4]) { return a[0] + a[1] + a[2] + a[3]; }

Programozás C és C++ -ban

Programozási technikák Pál László. Sapientia EMTE, Csíkszereda, 2009/2010

Absztrakt adattípus - algebrai specifikáció - Lists (paraméteres) module imports end exports parameters variables sorts operations equations

Adatbázis Rendszerek II. 5. PLSQL Csomagok 16/1B IT MAN

Tisztán funkcionális adatszerkezetek (folytatás)

Fejlett programozási nyelvek C++ Iterátorok

Programozás III CSOMAGOK. Az összetartozó osztályok és interfészek egy csomagba (package) kerülnek.

Programozás 6. Dr. Iványi Péter

Delphi programozás IV.

C programozás. 6 óra Függvények, függvényszerű makrók, globális és

Komputeralgebra Rendszerek

Programozás II. 4. Dr. Iványi Péter

Átírás:

Típusos Prolog

Típus fogalma Egy adott paraméter pozíción értelmes tömör Prolog kifejezések halmaza Prologban általában nincs típushiba, a hiba hatására a hívás meghiúsul. tarcsaz(bejegyzes(nev,szam),szam). tarcsaz(b( Bela,2131233),Tone). no Hibajelzést csak beépített típusok esetében kapunk X is 1+alma Domain error in argument 2 of is/2 Expected expression, found alma Goal: _79 is 1+alma Sicstus Prologban nincs típusdeklaráció (csak az olvasást megkönnyítendő fejkomment).

Mercury típusnyelve Elsősorban adatstruktúrák kialakítására alkalmas. Beépített típusok Ismert primitív típusok char int float string number Predikátum típusok: A predikátumok argumentumainak típusát határozza meg pred, pred(t) :- pred is_all_uppercase(string) Függvény típusok: A függvények argumentumainak és visszatérési értékének típusát határozza meg func(t1,t2)=t :- func length(list(t))=int

Tuple n-esek :- type {Arg1, Arg2,, ArgN} ---> {{Arg1, Arg2,, ArgN}} Miért szükséges az két egymásba ágyazott kapcsos zárójel??? {} Általános funktornév prefix alakban: {} (Arg1,.. ArgN) De mint sznitaktikai édesítőszer : {Arg1, ArgN} {} ((Arg1,, ArgN)) Tehát egyargumentumú funktornak képződik le A típus deklarációban külső kapcsos záró jelek mentesítik a belsőket az alól, hogy a prolog édesítőszernek értelmezze azokat.

Univerzális típus Standard library std_util moduljában type_to_univ/2 és univ_to_type_2 predikátumokkal konvertálhatóak. Heterogén kollekciókban.

Felhasználói típusok Új típusokat a :-type deklarációval hozunk létre Megkülönböztetett unió becsomagolt adatok Megkülönböztett unió: véges sok különböző funktorú típusból képzett halmaz uniója Mercury-ban csak megkülönböztetett uniók használhatóak. Sicstus Prologban megengedett legfeljebb kevésbé hatékony :-type t--->s1(t1,t2,...,tn1);...; sm(t1,t2,...,tnm). ni=0 esetén constans

:-type tree ---> leaf(integer);node(tree,tree). sum_tree(tree, S):- Tree=leaf(Value), S=Value. sum_tree(tree, S):- Tree=node(Left,Right), sum_tree(left, S1), sum_tree(right, S2), S is S1 +S2. Miért jó ez nekünk???

Kényelmes node(4,node(3,4)) alak helyett node(leaf(4),node(leaf(3), leaf(4))) alakot kell alkalmaznunk első alakhoz sum_tree2(tree, S):- integer(tree), S=Tree. klózra kéne kicserélni az elsőt. Ezt már nem lehet visszafele számolásra alkalmazni. Ez Mercury-ban nem is megengedett.

Sicstus-ban derive(x, 1). derive(c, 0):-integer(C). derive(u+v, DU+DV):- derive(u,du), derive(v,dv). Jó volna ha ugyan ezzel tudnánk integrálni is!

Megoldás: Csomagoljuk be a constanst! derive(x, 1). derive(const(c), 0). derive(u+v, DU+DV):- derive(u,du), derive(v,dv). Így viszont emberi szemmel nehezebben olvashatóak a kifejezések: x+3 helyett x+const(3)

További alkalmazások a megkülönböztetett uniókra: Enumeráció szerű: :- type fruit ---> ; apple ; orange ; banana. Rekord szerű: :- type employee ---> employee( name ::string, age ::int, department ::string ).

Polymorf :- type pair(t1,t2) ---> T1 - T2. first(p::pair(string,integer),f::string) :- P = First Sec, F = First.

Ekvivalencia típus Egyszerű típus szinonima :- type money==int. Egy adott szerkezet megvalósítását írja le: :- type assoc_list(keytype, ValueType) == list(pair(keytype),valuetype) Nem lehet rekurzív! Absztrakt típusok A típus implementációja hiányzik. Modulok interface részében használatosak :- type t1. :- type t2(t1,t2).

Módok A behelyettesítettségi állapottól függően fogalmazhatjuk meg a klózokat. in: behelyettesített változót várunk out: szabad változót várunk, és a klóz helyettesíti be tömör kifejezéssé. Behelyettesítettség Típus fa: vagy-csomópont : típusokat reprezentálnak és-csomópontok : konstruktorokat reprezentálnak Behelyettesítettségi fa: A vagy-csomópontokhoz rendel behelyettesítettségi információt. free Szabad ground - Tömör.

A felhasználó neveket deklarálhat az egyes behelyettesítettségi fáknak :- inst listskel == bound([]; [free listskel]). [A,B] Kielégíti [H T] nem elégíti ki, mert a váz csak egy része ismert. [A,2] nem elégíti ki, mert van egy tömör elem [A,A] nem elégíti ki, mert a két elem nem független egymástól A fenti kifejezéssel ekvivalens a bound/1 szintaktikai édesítőszere: :- inst listskel ---> [] ; [free listskel].

Másik példa, opcionális típus behelyettesíttettségi fája: :- inst maybeskel == bound(no;yes(ground)). vagy :- inst maybeskel ---> no;yes(ground).

Parametrizált behelyettesíttettségi fák: :- inst listskel(inst) = bound([];[inst listskel(inst)]). :- inst maybeskel(inst) ---> no; yes(inst).

Módok általánosabban Behelyettesítettségi állapot megváltozását írják le a klóz végrehajtása alatt. :- mode m == inst1 >> inst2. Az beépített alapmódok móddeklarációja ezek után: :- mode in == ground >> ground. :- mode out == free >> ground.

Módok átnevezése: :- mode (+) == in. :- mode (-) == out. Parametrizált módok: :- mode in(inst) == Inst >> Inst. :- mode out(inst) == free >> Inst.

Predikatum és Függvénymód deklaráció: :- mode out_listskel == free >> listskel. :- mode in_listskel == listskel >> listskel. :- func length(list(t)) = int :- mode length(in_listskel)=out :- mode length(out_listskel)=in :- pred append(list(t), list(t), list(t)). :- mode append(in, in, out). :- mode append(out, out, in). Mind a függvényeknek mind a predikátumoknak több módja is lehet

A length függvény esetében használhatjuk a standard library parametrikus in/1, és out/1 módját :- func length(list(t)) = int :- mode length(in(listskel))=out :- mode length(out(listskel))=in

Típusosztályok Olyan típusok halmaza melyre biztosított, hogy adott függvények és predikátumok meghívhatóak, alkalmazhatóak. :- typeclass point(t) where [ pred coords(t, float, float), mode coords(in, out, out), func translate(t, float, float) = T ].

Típust a típusosztályba az instance deklarációval vehetünk fel. :- type coordinate --->coordinate( float, float ). :- instance point(coordinate) where[ Pred(coords/3) is coordinate_coords, Func(translate/3) is coordinate_translate ].

:- pred coordinate_coords(coordinate, float, float). :- mode coordinate_coords(in, out, out). coordinate_coords(coordinate(x,y), X, Y). :- func coordinate_translate(coordinate, float, float)= coordinate. coordinate_translate(coordinate(x,y), Dx, Dy)= coordinate(x+dx,y+dy).

Hasonlóan felvehetjük a színes pont típust is a pont típusosztályba :- type rgb ---> rgb(int,int,int). :- type coloured_coordinate --->coordinate( float, float, rgb ). :- instance point(coloured_coordinate) where[ Pred(coords/3) is coloured_coordinate_coords, Func(translate/3) is coloured_coordinate_translate ].

:- pred coloured_coordinate_coords(coloured_coordinate, float, float). :- mode coloured_coordinate_coords(in, out, out). coloured_coordinate_coords(coloured_coordinate(x,y,_), X, Y). :- func coloured_coordinate_translate(coloured_coordinate, float, float)= coloured_coordinate. coloured_coordinate_translate(coloured_coordinate(x,y,c), Dx, Dy)= coloured_coordinate(x+dx,y+dy,c).

Típusosztály korlát predikátumokra és függvényekre :- pred distance(p1, P2, float) <= (point(p1),point(p2)). :- mode distance(in, in, out). distance(a, B, Distance) :- coords(a, Xa, Ya), coords(b, Xb, Yb), XDist is Xa-Xb, YDist is Ya-Yb, Distance = sqrt(xdist* XDist+ YDist* YDist).

Típusosztály korlát típusosztályra :- typeclass ring(t) where [ func zero=(t::out), func one=(t::out), func plus(t::in, T::in)=(T::out), func mult(t::in, T::in)=(T::out), func negative(t::in)=(t::out) ]. :- typeclass euclidean(t) <= ring(t) where [ func div(t::in, T::in)=(T::out), func mod(t::in, T::in)=(T::out) ]. Az euclidean osztályba sorolt típusoknak ki kell elégíteniük a gyűrűbe tartozás feltételét is. Ismerős? Tulajdonképpen öröklődésről beszélünk.

Ciao Prolog típusnyelve Típusok szemantikájának meghatározására is lehetőséget ad. Tulajdonságok (Properties) Speciális predikátumok, melyek eleget tesznek annak a feltételnek, hogy a behelyettesítettségi állapotot nem változtatják meg. :- prop intlist(l). intlist([]). intlist([x R]):-int(X),intlist(R). sumlist([],0). sumlist([x R],S):- sumlist(r,ps), S is PS+X. :- calls sumlist(l,n) : intlist(l). A hívások során elvégzi az L argumentumra az intlist/1 ellenőrzést

Adott az alábbi predikátum: string_concat([],l,l). string_concat([x Xs],L,[X NL]):- string_concat(xs,l,nl). Mely ASCII kódban ábrázolt karakterek listájából álló stringet konkatenál.

:-success string_concat(a,b,c) => (compatible_with_intlist(a), compatible_with_intlist(b), compatible_with_intlist(c)). :-prop compatible_with_intlist/1. compatible_with_intlist(x) :- var(x). compatible_with_intlist(x) :- nonvar(x), compatible_with_intlist_aux(x). compatible_with_intlist_aux([]). compatible_with_intlist_aux([x T]) :- int_compat(x), compatible_with_intlist_aux(t). int_compat(x) :- var(x). int_compat(x) :- nonvar(x), integer(x).

Láthatjuk, hogy a compat előtag azt jeleni, hogy megvizsgájuk, hogy az argumentum változó e, ha nem változó, akkor valamilyen más tulajdonságot vizsgálunk az argumentumra (pl.: intlist/1) Erre használhatjuk a standard könyvtár ilyen nevű tulajdonságát: :-success string_concat(a,b,c) => (compat(intlist(a)), compat(intlist(b)), compat(intlist(c))).

Felhasznált irodalom: - The Mercury Language Reference Manual - The Ciao Prolog System - Reference Manual - Benkő Tamás: A Mercury nagyhatékonyságú LP megvalósítás