„Típuskövetkeztetés” változatai közötti eltérés

fordítás sablon a szerző alapján
a (Vépi átnevezte a(z) Típus következtetés lapot a következő névre: Típuskövetkeztetés: helyesírás)
(fordítás sablon a szerző alapján)
'''A típus következtetéstípuskövetkeztetés a''' kifejezés típusának automatikus felismerésére vonatkozik egy [[Formális nyelv|formális nyelven]] . Ide tartoznak a [[Programozási nyelv|programozási nyelvek]] és a matematikai típusú rendszerek, de [[Számítástudomány|a számítástechnika]] és a [[nyelvészet]] egyes ágaiba a [[Természetes nyelv|természetes nyelvek]] is beletartoznak.
 
== Műszaki magyarázat ==
A legáltalánosabb nézetben szereplő típusok társíthatók olyan kiválasztott felhasználásokhoz, amelyek javasolják és korlátozzák az adott típusú objektumok lehetséges műveleteit. A nyelvben számos főnév határozza meg ezt a használatot. Például a póráz szónak más célja van, mint a sor szónak. Ha valamit [[Asztal|asztal táblának]] hívunk, annak jelentése eltér a [[Tűzifa|tűzifának]] nevező táblától, annak ellenére, hogy nagyjából azonos lehet. Noha anyagi tulajdonságaik miatt ezek a dolgok bizonyos célokra hasznosak, mégis sajátos nevekkel rendelkeznek. Ez különösen igaz az absztrakt területeken, nevezetesen a matematikában és az informatikában, ahol az anyag végül csak egy bitek vagy formulák.
 
A felesleges, de gazdaságilag lehetséges felhasználások kizárása érdekében a típus fogalmát számos változatban definiálják és alkalmazzák. A matematikában [[:en:Russell's_paradox|Russell's paradoxa]] hozta létre a típuselmélet korai verzióit. A programozási nyelvekben egyik tipikus példa a "típushiba", például a számítógép olyan összeszámolásra utasít, amely nem szám. Bár megvalósítható, az eredmények már nem lesznek értelmezhetőek, és súlyos következményekkel járhatnak az egész folyamatra nézve.
 
A típusokban a kifejezések a típusokhoz viszonyulnak. Például a <math>4</math>, <math>2+2</math>, és <math>2\cdot 2</math> és a <math>2\cdot 2</math> független kifejezések, és <math>\mathrm{nat}</math> típusú természetes számok. Hagyományosan a kifejezést kettőspont követi, és annak típusa, mint pl <math>2 : \mathrm{nat}</math> . Ez azt jelenti, hogy a <math>2</math>-es érték típusa <math>\mathrm{nat}</math> . Ezt az űrlapot új nevek deklarálására is használják, pl <math>n : \mathrm{nat}</math>, hasonlóan ahhoz, hogy egy "Decker nyomozó" szavakkal új karaktert mutassanak be a jelenetben.
 
Ellentétben azokkal a történetekkel, amelyekben a szimbólumok lassan bontakoznak ki, a hivatalos nyelvi objektumokat általában kezdettől fogva típusuk szerint kell meghatározni. Ezenkívül, ha a feltételek nem egyértelműek, a típus megadására lehet szükség a cél megadásához. Például a <math>2</math>-es kifejezés lehet <math>\mathrm{nat}</math> típus, de racionális vagy valós számként, vagy akár egyszerű szövegként is olvasható.
Ennek következményeként a programok vagy eljárások túlterhelődnek a típusokkal, amennyiben azokat a kontextusból kell szármoztatni. Ezt úgy lehet elérni, hogy összegyűjtjük a nem típusú kifejezések használatát (beleértve a meghatározatlan neveket is). Például, ha <math>n + 2</math> meghatározatlan nevet használ a kifejezésben, arra következtethet, hogy ''n'' legalább egy szám. A típus kifejezésből és összefüggéséből történő levezetésének folyamata a típus következtetése.
 
Általánosságban elmondható, hogy nem csak az objektumoknak, hanem az eljárásoknak is vannak típusaik, amelyek használatukkal könnyen bevezethetők. A Star Trek történetéhez egy ilyen ismeretlen eseményt "lehet közvetíteni", de hivatalosan soha nem indították el, csak hogy a történet folytatódhasson. Mindazonálltal a típusára (szállítására) azonban a történtekből lehet következtetni. Ezenkívül objektumok és tevékenységek felépíthetők a részeikből. Ebben az esetben a típus következtetéstípuskövetkeztetés nemcsak bonyolultabbá válik, hanem hasznosabbá is válik, mert lehetővé teszi, hogy teljes leírást gyűjtsön az összeszerelési jelenetben mindenről, ugyanakkor képes legyen észlelni az összeütközéseket vagy a nem szándékos felhasználást.
 
== Típusellenőrzés vs típuskövetkeztetés ==
 
# E : T? Ebben az esetben E-kifejezést és T-t is megadunk. Most E valóban T? Ez a forgatókönyv típusellenőrzés néven ismert.
# E : _? Itt csak a kifejezés ismert. Ha van mód az E típusának levezetésére, akkor elvégeztük a ''típus következtetésttípuskövetkeztetést'' .
# _ : T? Fordítva. Csak egy típust adva, van-e kifejezés rá, vagy a típusnak nincsenek értékei? Van-e példa T-re?
 
Az egyszerű, tipizált lambda számításokhoz mindhárom probléma meghatározható. Amikor kifejezőbb típusok megengedettek, a helyzet kevésbé kényelmes.
 
A típusok olyan jellemzők, amelyek jelen vannak néhány erősen statikusan tipizált nyelvben. Ez kifejezetten gyakran jellemző a [[Funkcionális programozás|funkcionális programozási nyelvekre]] általában. Egyes nyelvek közé típusú következtetést tartalmaznia C ++ 11, C # (3.0 verziótól kezdődően), [[:en:Chapel_(programming_language)|Chapel]], [[:en:Clean_(programming_language)|Clean]], [[:en:Crystal_(programming_language)|Crystal]], [[:en:D_(programming_language)|D]], [[:en:F_Sharp_(programming_language)|F#]],<ref>{{Cite web |last=cartermp |title=Type Inference - F# |url=https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/type-inference |access-date=2020-11-21 |website=docs.microsoft.com |language=en-us}}</ref> [[:en:FreeBASIC|FreeBASIC]], [[:en:Go_(programming_language)|Go]], [[:en:Haskell_(programming_language)|Haskell]], [[:en:Java_(programming_language)|Java]] (verziótól kezdődően 10),[[:en:Julia_(programming_language)|Julia]],<ref>{{Cite web |title=Inference · The Julia Language |url=https://docs.julialang.org/en/v1/devdocs/inference/ |access-date=2020-11-21 |website=docs.julialang.org}}</ref> [[:en:Kotlin_(programming_language)|Kotlin]], [[:en:ML_(programming_language)|ML]], [[:en:Nim_(programming_language)|Nim]], [[:en:OCaml|OCaml]], [[:en:Opa_(programming_language)|Opa]], [[:en:RPython|RPython]], [[:en:Rust_(programming_language)|Rust]], [[:en:Scala_(programming_language)|Scala]],<ref>{{Cite web |title=Type Inference |url=https://docs.scala-lang.org/tour/type-inference.html |access-date=2020-11-21 |website=Scala Documentation}}</ref> [[:en:Swift_(programming_language)|Swift]], [[:en:TypeScript|TypeScript]],<ref>{{Cite web |title=Documentation - Type Inference |url=https://www.typescriptlang.org/docs/handbook/type-inference.html |access-date=2020-11-21 |website=www.typescriptlang.org |language=en}}</ref> [[:en:Vala_(programming_language)|Vala]], [[:en:Dart_(programming_language)|Dart]],<ref>{{Cite web |title=The Dart type system |url=https://dart.dev/guides/language/type-system |access-date=2020-11-21 |website=dart.dev}}</ref> és <a href="https://en.wikipedia.org/wiki/Visual_Basic_.NET#2008_(VB_9.0)" rel="mw:ExtLink" title="Visual Basic .NET" class="cx-link" data-linkid="170">Visual Basic</a> (kezdve a 9.0 verziótól). Többségük a típus következtetéstípuskövetkeztetés egyszerű formáját alkalmazza; a Hindley-Milner típusú rendszer teljesebb típusú következtetésre képes. A típusok kikövetkeztetésének képessége sok programozási feladatot megkönnyít, így a programozó szabadon hagyhatja a típusjegyzeteket, miközben engedélyezi a típusellenőrzést.
 
Bizonyos programozási nyelvekben minden értéknek van egy [[Adattípus|adattípusa, amelyet]] kifejezetten deklaráltak a fordítás idején, ami korlátozza azokat az értékeket, amelyeket egy adott kifejezés futás közben kaphat. Ami leginkább ellentmondásossá teszi a fordítási idő és a futási idő közti különbséget, az a [[Futásidejű fordítás|just-in-time fordítás]]. Azonban, történelmileg, ha az érték típusa csak futás közben ismert, akkor ezeket a nyelveket dinamikusan gépelik . Eltérő nyelvekben a kifejezés típusa csak fordításkor ismert; az ilyen nyelvek tipizálása statikusan történik. A legtöbb statikusan tipizált nyelvben a függvények és a helyi változók bemeneti és kimeneti típusait általában típusjegyzetekkel adják meg. Például a [[C (programozási nyelv)|C-ben]] :<syntaxhighlight lang="c">
int add_one(int x) {
int result; /* egész eredmény deklarálása */
result2 = x + 1.0; /* ez a sor nem fog működni (a javasolt nyelven) */
return result;
}</syntaxhighlight>Ez megegyezik a [[Dart (programozási nyelv)|Dart]] nyelven írt kóddal, de további korlátozások vonatkoznak rá, az alábbiakban leírtak szerint. A fordítás során az összes változó típusára ''következtetni'' lehet. A fenti példában a fordító arra a következtetésre jutott, hogy a<code>result-nak</code> és az<code>x</code>-nek egész típusúnak kell lennie, mivel az <code>1</code>. konstans típusú egész szám, tehát az <code>add_one</code> egy <code>int -> int</code> függvény. Az <code>result2</code> változót törvényszerűen nem használják, így nem lesz típusa.
 
Az utolsó példát író fiktív nyelvben a fordító azt feltételezte, hogy hacsak másképp nem jelezzük, a <code>+</code> két egész számot elfogad és egy egész számot ad vissza. (Például az [[:en:OCaml|OCaml]].így működik.) Ebből a következtetéstípusból arra következtethetünk, hogy az <code>x + 1</code>típusa egész szám, ami azt jelenti, hogy a <code>result</code> egész szám, tehát az <code>add_one</code>visszatérési értéke egész szám. , Mivel a <code>+</code>megköveteli, hogy a két paraméter azonos típusú legyen, <code>x</code>-nek egész számnak kell lennie, ezért az <code>add_one</code>egész számot fogad el paraméterként.
 
== Technikai leírás ==
A típus következtetéstípuskövetkeztetés az a képesség, hogy a kifejezés típusát részben vagy egészben a fordítás idején levezethetjük. A fordító általában képes egyértelmű következtetéstípus megadása nélkül kikövetkeztetni a változó típusát vagy a függvény típusaláírását. Sok esetben, ha a típusú következtetési rendszer elég robusztus, vagy a program vagy a nyelv elég egyszerű, a típusjegyzeteket teljesen el lehet hagyni.
 
A kifejezés típusának meghatározásához szükséges információk megszerzése érdekében a fordító összegyűjti ezeket az információkat, és leegyszerűsíti az alkifejezéséhez hozzáadott típusjegyzeteket, vagy hallgatólagosan megérti a különböző atomértékek típusait (például igaz : logikai; 42 : egész szám; 3.14159 : valódi; stb.). Annak felismerésével, hogy a kifejezések implicit módon beírható atomértékekre redukálódhatnak, a következtetett nyelv fordítója teljesen megírhatja a programot anélkül, hogy tipusjegyzetekre lenne szüksége.
 
[[Magas szintű programozási nyelv|A magasabb szintű programozás]] és a [[Polimorfizmus (informatika)|polimorfizmus]] bonyolult formáiban a fordító nem mindig következtethet ennyire, és a finomításhoz időnként tipikus kommentárokra van szükség. Például a polimorf rekurzióval kapcsolatos típusú következtetéseket nem lehet cáfolni. Ezenkívül azzal, hogy a fordítót arra kényszeríti, hogy a következtetett típusnál specifikusabb (gyorsabb / kisebb) típust használjon, explicit típusú kommentárokkal használhatja a kód optimalizálását. <ref>{{Hivatkozás/Könyv |last=Bryan O'Sullivan |title=Real World Haskell |year=2008 |publisher=O'Reilly |chapter=Chapter 25. Profiling and optimization |chapterurl=http://book.realworldhaskell.org/read/profiling-and-optimization.html}}</ref>
 
A típusú következtetés egyes módszerei a [https://hu.wikiqube.net/wiki/Constraint_satisfaction kényszer-elégedettségen] <ref>Talpin, Jean-Pierre, and Pierre Jouvelot. "[https://pdfs.semanticscholar.org/57b0/e240c36a26c05b2eb7b6ccf3fabbfd383b25.pdf Polymorphic type, region and effect inference]." Journal of functional programming 2.3 (1992): 245-271.</ref> vagy az [https://hu.wikinew.wiki/wiki/Satisfiability_modulo_theories elégedettség modulo-elméleteken] alapulnak. <ref>{{Hivatkozás/Könyv |last=Hassan |first=Mostafa |title=Computer Aided Verification |series=Lecture Notes in Computer Science |year=2018 |isbn=978-3-319-96141-5 |doi=10.1007/978-3-319-96142-2_2 |page=12–19 |chapter=MaxSMT-Based Type Inference for Python 3 |chapterurl=https://link.springer.com/chapter/10.1007/978-3-319-96142-2_2}}</ref>
 
Példaként, a [[Haskell (programozási nyelv)|Haskell]] funkció <code>map</code> v egy listának minden eleme egy funkcióra vonatkozik, és lehet meghatározni:<syntaxhighlight lang="haskell">
map f (first:rest) = f first : map f rest
 
</syntaxhighlight>A típus következtetéstípuskövetkeztetés a <code>map</code> funkció a következőképpen jár el. A <code>map</code> két argumentum funkciója, ezért típusa <code>a → b → c</code> alakú. Haskellben a <code>[]</code> és <code>(first:rest)</code> mindig egyeznek a minták a listákkal, tehát a második argumentumnak mindíg listatípusnak kell lennie: <code>b = [d]</code> <code>d</code> típus esetében. Első argomentum az <code>f</code> alkalmazzuk a <code>first</code> az argumentumra, ami mindenképpen <code>d</code> típusúnak kell lennie, amely megegyezik a lista argumentum típusával, tehát <code>f :: d → e</code> ( <code>::</code> jelentése "a típusa") bizonyos <code>e</code> típusoknál. A visszatérési értéke <code>map f,</code> végezetük, felsorolja azt, amit <code>f</code> produkál, tehát <code>[e]</code> .
 
Ha megfelelően összerakjuk a részeket, <code>map :: (d → e) → [d] → [e]</code> . A típusváltozókban nincs semmi különös, ezért megjegyezhetjük őket<syntaxhighlight lang="haskell">
map :: (a → b) → [a] → [b]
 
Az eredetileg a típusú következtetések végrehajtására használt algoritmust ma informálisan Hindley-Milner algoritmusnak nevezik, bár az algoritmust Damasknak, illetve Milnernek kell tulajdonítani.<ref name="Damas-and-Milner-1982">{{Citation|author1=Damas|author2=Milner|title=POPL '82: Proceedings of the 9th ACM SIGPLAN-SIGACT symposium on principles of programming languages|publisher=ACM|year=1982}}</ref>
 
Ennek az algoritmusnak az eredete [[:en:Haskell_Curry|Haskell Curry]] és [[:en:Robert_Feys|Robert Feys]] által 1958-ban kitalált egyszerű típusú lambda számítási érvelési algoritmus. 1969-ben [[:en:J._Roger_Hindley|J. Roger Hindley]] kiterjesztette ezt a munkát, és bebizonyította, hogy algoritmusuk mindig a leggyakoribb típust vezeti le. 1978-ban [[:en:Robin_Milner|Robin Milner]],<ref>{{Citation|last1=Milner|first1=Robin|title=A Theory of Type Polymorphism in Programming|journal=Journal of Computer and System Sciences|pages=348–375|volume=17|issue=3|year=1978|doi=10.1016/0022-0000(78)90014-4|doi-access=free}}</ref>, Hindley munkájától függetlenül, egy ekvivalens algoritmust, a W algoritmust biztosított. [[:en:Luis_Damas|Luis Damas]] <ref name="Damas-and-Milner-19822">{{Citation|last1=Damas|first1=Luis|last2=Milner|first2=Robin|contribution=Principal type-schemes for functional programs|title=POPL '82: Proceedings of the 9th ACM SIGPLAN-SIGACT symposium on principles of programming languages|publisher=ACM|pages=207–212|year=1982|url=http://groups.csail.mit.edu/pag/6.883/readings/p207-damas.pdf}}</ref> végül bebizonyította, hogy Milner algoritmusa 1982-ben elkészült, és kiterjesztette polimorf referenciákkal rendelkező rendszerek támogatására.
 
== A legáltalánosabb típus használatának mellékhatásai ==
A tervezés szerint a típus következtetéstípuskövetkeztetés, különösen korrekt (visszalépési) típusú következtetés a leggyakoribb típusok használatát foglalja magában, de ennek következményei lehetnek, mert az általánosabb típusok nem mindig algoritmus semlegesek. A tipikus helyzet:
 
* a lebegőpontos egész szám általános típusának tekinthető, míg a lebegőpontos pontossági kérdéseket fog bevezetni
* a variáns / dinamikus típusok más típusok általános típusának tekinthetők, amelyek bevetési szabályokat és összehasonlítást vezetnek be, amelyek eltérőek lehetnek, például az ilyen típusok a „+” operátort használják mind numerikus kiegészítésekhez, mind karakterláncok összefűzéséhez, de a műveletet milyen inkább dinamikusan, mint statikusan határozzák meg
 
== Típus következtetésTípuskövetkeztetés a természetes nyelvekre ==
A típus következtetésitípuskövetkeztetési algoritmusokat használták a [[Természetes nyelv|természetes nyelvek]], valamint a programozási nyelvek elemzésére. <ref>Center, Artificiał Intelligence. [https://www.sri.com/sites/default/files/uploads/publications/pdf/511.pdf Parsing and type inference for natural and computer languages]. Diss. Stanford University, 1989.</ref> <ref>Emele, Martin C., and Rémi Zajac. "[https://aclanthology.info/pdf/C/C90/C90-3052.pdf Typed unification grammars]." Proceedings of the 13th conference on Computational linguistics-Volume 3. Association for Computational Linguistics, 1990.</ref> <ref>Pareschi, Remo. "[https://www.era.lib.ed.ac.uk/bitstream/handle/1842/19215/PareschiR_1989redux.pdf?sequence=1 Type-driven natural language analysis]." (1988).</ref> A típus következtetésitípuskövetkeztetési algoritmusokat néhány nyelvtani indukciós <ref>Fisher, Kathleen, et al. "Fisher, Kathleen, et al. "[https://www.cs.princeton.edu/~dpw/papers/learningpopl08-final.pdf From dirt to shovels: fully automatic tool generation from ad hoc data]." ACM SIGPLAN Notices. Vol. 43. No. 1. ACM, 2008." ACM SIGPLAN Notices. Vol. 43. No. 1. ACM, 2008.</ref> <ref>{{Cite journal|author=Lappin|first=Shalom|year=2007|title=Machine learning theory and practice as a source of insight into universal grammar|url=https://dash.harvard.edu/bitstream/handle/1/2031673/MachineLearning.pdf?sequence=3|journal=Journal of Linguistics|volume=43|issue=2|pages=393–427|doi=10.1017/s0022226707004628}}</ref> és kényszer alapú nyelvtani rendszerben is használják a természetes nyelvek számára. <ref name="Shieber1992">{{Hivatkozás/Könyv |last=Stuart M. Shieber |title=Constraint-based Grammar Formalisms: Parsing and Type Inference for Natural and Computer Languages |url=https://books.google.com/books?id=QcYl_ylrHmcC&q=%22type+inference%22 |year=1992 |publisher=MIT Press |isbn=978-0-262-19324-5}}</ref>
 
== Hivatkozások ==
 {{Reflistjegyzetek}}
 
== Külső linkekFordítás ==
{{fordítás|en|Type inference|oldid=1019307176}}
 
== További információk ==
* [http://www.cis.upenn.edu/~bcpierce/types/archives/1988/msg00042.html Archived e-mail message] - Roger Hindley, elmagyarázza a típus következtetésének történetét
* [http://www.brics.dk/~mis/typeinf.pdf Polymorphic Type Inference] - Michael Schwartzbach, áttekintést ad a polimorf típusú következtetést.
* [http://lucacardelli.name/Papers/BasicTypechecking.pdf Basic Typeckecking] - Luca Cardelli papírja, leírja az algoritmust, és magában foglalja a [[Modula-2 (programozási nyelv)|Modula-2 megvalósítását]]
* [http://dysphoria.net/2009/06/28/hindley-milner-type-inference-in-scala/ Implementation] - Hindley-Milner típusú következtetések a Scala, Andrew Forrest (letöltött július 30, 2009)
* {{Webarchive|url=https://web.archive.org/web/20070218103011/http://www.cs.berkeley.edu/~nikitab/courses/cs263/hm.html|date=February 18, 2007|title=Implementation of Hindley-Milner in Perl 5, by Nikita Borisov}}
* [http://www.codecommit.com/blog/scala/what-is-hindley-milner-and-why-is-it-cool What is Hindley-Milner? (and why is it cool?] [http://www.codecommit.com/blog/scala/what-is-hindley-milner-and-why-is-it-cool )] Elmagyarázza a Hindley-Milner -példákat a Scalában