| OCaml | |
|---|---|
| Szemantika | több paradigma : funkcionális , objektum-orientált , kötelező |
| Nyelvóra | objektumorientált programozási nyelv , funkcionális programozási nyelv , többparadigmás programozási nyelv , kötelező programozási nyelv , programozási nyelv és ingyenes és nyílt forráskódú szoftverek |
| Megjelent | 1996 |
| Szerző | Leroy, Xavier és Damien Doligez [d] |
| Fejlesztő | INRIA |
| Fájlkiterjesztés _ | .ml, .mli |
| Kiadás | 4.14.0 ( 2022. március 28. ) |
| Típusrendszer | szigorú , statikus |
| Dialektusok | F# , JoCaml , MetaOCaml, OcamlP3l |
| Befolyásolva | Standard ML , Caml Light |
| Engedély | LGPL |
| Weboldal | ocaml.org |
| OS | Unix-szerű operációs rendszer [1] |
| Médiafájlok a Wikimedia Commons oldalon | |
Az OCaml ( Objective Caml ) egy általános célú objektum-orientált funkcionális programozási nyelv . Úgy tervezték, hogy szem előtt tartva a végrehajtás biztonságát és a programok megbízhatóságát. Támogatja a funkcionális, kötelező és objektum-orientált programozási paradigmákat. Az ML nyelv leggyakoribb dialektusa a gyakorlati munkában .
1996 - ban jelent meg Objective Caml néven, amikor Didier Rémy (Didier Rémy) és Jérôme Vouillon (Jérôme Vouillon) támogatta az eredetileg az INRIA Francia Intézetben kifejlesztett Caml nyelv objektum-orientált programozását . Hivatalosan átnevezték OCaml-re 2011-ben [2] .
Az OCaml eszközkészlet tartalmaz egy értelmezőt , egy bájtkódoló fordítót és egy natív kódra optimalizáló fordítót, amely hatékonysága összehasonlítható a Java -val, teljesítményében pedig csak valamivel gyengébb a C -nél és C++-nál [3] .
Különösen a Wikipédia képletek megjelenítése a <math> címkével, az MLDonkey fájlcserélő klienssel , a Xen xapi hypervisor vezérlő veremével (a Xen Server / Xen Cloud Platform része) és a Haxe programozási nyelvvel az OCaml-ben van megírva. nyelv .
Az OCaml nyelv egy általános célú programozási nyelv, de megvannak a maga meghatározott alkalmazási területei [4] .
Először is "biztonságos" (nem csak információbiztonsági értelemben vett) alkalmazások létrehozásáról van szó. A nyelv szemétgyűjtést használ, és a legtöbb adattípus referencia ( angolul boxed ), ami a puffer túlcsordulás megakadályozását jelenti a program végrehajtása során. Ezenkívül a statikus gépelés és a fordítási idő ellenőrzése bizonyos más hibaosztályokat, például az öntési hibákat lehetetlenné teszi az automatikus típusöntés hiánya miatt. Ezenkívül a kód formálisan ellenőrizhető . Vannak segédprogramok a kód típushelyességének automatikus bizonyítására, amelyek jobbak, mint a legtöbb programozási nyelv esetében. És ami fontos, a biztonsági intézkedések nem befolyásolják a végrehajtható kód hatékonyságát [4] .
Az OCaml sikerének másik területe az adatvezérelt alkalmazások . Ez a terület magában foglalja a szövegfeldolgozást, valamint az írás-fordítókat. Az OCaml nemcsak szövegfeldolgozási eszközökkel rendelkezik (amiről például a Perl vagy az AWK híres ), hanem a mély szemantikai elemzéshez és a szövegátalakításhoz is, ami az OCaml-t adatbányászati feladatokban is alkalmazhatóvá teszi [ 4 ] .
Természetesen az OCaml-t az ML többi dialektusához hasonlóan kutatási és ellenőrzési feladatokban használják, amelyekben a fő kódot valamilyen programozási nyelven írják, majd egy OCaml program formálisan ellenőrzi és elemzi [4] . Például a Coq interaktív tételbizonyító rendszer OCaml nyelven íródott .
Az OCaml különleges helyet foglal el a programozási nyelvek között a hatékonyság, a kifejezőkészség és a praktikum kombinációja miatt. Az ML létrehozása óta több mint 40 év alatt kialakult nyelv jellemzői közé tartozik [5] :
Az OCaml eredete az ML-ből ( eng. meta language ) származik, amelyet Robin Milner 1972 - ben implementált a Lisp dialektusban tételek bizonyítására szolgáló szoftverként, mint a kiszámítható függvények logikájának metanyelve (LCF, eng. logic for computable ). funkciók ). Később egy fordító is készült , és 1980- ra az ML teljes értékű programozási rendszerré vált [6] .
Guy Cousineau algebrai adattípusokat és mintaillesztést adott a nyelvhez, és az ML-t kategorikus absztrakt gépként (CAM) határozta meg. Így a CAM-ML leírható, ellenőrizhető és optimalizálható volt, ami előrelépést jelentett az ML számára [7] .
További fejlesztés volt a Caml nyelv (amelyet a CAM-ML újrajátszott) [6] [7] , amelyet 1987-ben Ascánder Suárez hozott létre, majd Pierre Weis és Michel Mauny folytatta .
1990 -ben Xavier Leroy és Damien Doligez kiadott egy új implementációt Caml Light néven . Ez a C megvalósítás bájtkód értelmezőt és gyors szemétgyűjtőt használt . A könyvtárak írásával a nyelvet az oktatási és kutatóintézetekben kezdték használni [6] [7] .
A C. Leroy által kifejlesztett Caml Special Light 1995 -ben látta meg a fényt . A programozó rendszer kapott egy gépi kódokba fordítót, amely a végrehajtható kód hatékonyságát egy szintre emelte a többi lefordított nyelvével. Ezzel egy időben egy modulrendszert fejlesztettek ki , amelynek ötletét a Standard ML -től kölcsönözték [6] .
Az OCaml modern formája 1996 -ra nyúlik vissza , amikor Didier Rémy és Jérôme Vouillon ügyes és hatékony objektumtámogatást vezetett be a nyelvhez . Ez az objektumrendszer lehetővé teszi objektumorientált programozási idiómák használatát fordítási időben, típusbiztos módon , a benne rejlő C++ és Java futásidejű ellenőrzések nélkül [6] .
A 2000-es években a nyelv zökkenőmentesen fejlődött, miközben egyre nagyobb elismerést kapott a kereskedelmi projektekben és az oktatásban. A jelenleg kidolgozottak közé tartoznak a polimorf módszerek és variánsok, a nevesített és opcionális paraméterek, az első osztályú modulok , az általánosított algebrai adattípusok (GADT). A nyelv több hardverplatformot kezdett támogatni ( X86 , ARM , SPARC , PowerPC ) [6] [7] .
Az OCaml, mint funkcionális programozási nyelv számítási modellje a lambda-számítás három fő konstrukcióján alapul : változókon , függvénydefiníciókon és egy függvény alkalmazásán argumentumokra [8] .
A változó olyan azonosító, amelynek értéke egy bizonyos értékhez van társítva. A változónevek kisbetűvel vagy aláhúzással kezdődnek. A kötés általában a kulcsszóval történik let, mint a következő példában egy interaktív shellben [9] :
legyen v = 1 ;;A változóknak hatókörük van . Például egy interaktív shellben egy változó használható a hozzárendelését követő parancsokban. Hasonlóképpen egy modulban definiált változó is használható, miután az adott modulban meghatározásra került [9] .
A változó kötés a let-in konstrukció által meghatározott hatókörben is elvégezhető, mint a következő példában a kör területének sugárból történő kiszámításához:
# legyen terület sugara = legyen pi = 3 . 14 sugárban * . sugár *. pi ;; val area : float -> float = < fun > # area 2 . 0 ;; - : úszó = 12 . 56Az OCaml-ben a változó-összerendelések megváltoztathatatlanok (mint a matematikai egyenleteknél), vagyis egy változó értékét csak egyszer „adják hozzá” (egyszeri hozzárendelés). Másik dolog, hogy a let-in belül lehet egy másik let-in, amiben egy másik változót vezetnek be, ami „árnyékolhatja” az elsőt [9] .
Számos szintaktikai konstrukció létezik az OCaml függvények meghatározására.
A függvények a segítségével definiálhatók function. A függvény kifejezése így néz ki [10] :
függvény x -> x + 1Ebben az esetben a függvény névtelen , és használható más függvények paramétereiként, vagy alkalmazható valamilyen argumentumra, például:
( x -> x + 1 függvény ) 5Ennek a függvénynek a típusa , azaz a függvény egy egész számotint -> int vesz fel, és egy egész számot ad vissza.
Egy függvénynek több argumentuma is lehet [11] :
függvény ( x , y ) -> x - yEbben a példában a típusa: int * int -> int, vagyis a függvény bemenete egy pár , a kimenete pedig egy egész szám.
Van egy másik megközelítés több argumentum függvényeinek ábrázolására – N-számú függvény konvertálása egy argumentum N függvényévé – currying . Az egész argumentumok szorzatát kiszámító függvény alábbi két jelölése egyenértékű [11] :
függvény x -> függvény y -> x * y móka x y -> x * yElnevezett függvényeket úgy kaphatunk, hogy egy változót egy függvényhez társítunk [10] . Egy elnevezett függvény definíciója annyira elterjedt művelet, hogy külön szintaktikai támogatással rendelkezik. A következő három bejegyzés egyenértékű módja egy függvény meghatározásának (interaktív shellben):
# let prod = függvény x -> függvény y -> x * y ;; val prod : int -> int -> int = < fun > # let prod x y = x * y ;; val prod : int -> int -> int = < fun > # let prod = fun x y -> x * y ;; val prod : int -> int -> int = < fun >Két argumentum függvényei definiálhatók az infix jelöléssel [10] :
# legyen (^^) x y = x ** 2 . 0+ . y ** 2 . 0 ;; val ( ^^ ) : float -> float -> float = < fun > # 2 . 0 ^^ 3 . 0 ;; - : úszó = 13 . # (^^) 2 . 0 3 . 0 ;; - : úszó = 13 .Ez a példa egy függvényt határoz meg, amely két lebegőpontos szám(^^) négyzetösszegét számítja ki . Az utolsó két jelöléstípus egyenértékű.
A rekurzív függvények , azaz a saját definíciójukra hivatkozó függvények a let rec[10] segítségével adhatók meg :
# legyen rec fac n = egyeztesse n -t | -vel 0 -> 1 | x -> x * fac ( x - 1 ) ;;Ugyanebben a faktorszámítási példában a mintaillesztést alkalmazzuk (construct match-with).
A függvényargumentumok név szerint definiálhatók. A megnevezett argumentumok tetszőleges sorrendben megadhatók [10] :
# legyen divmod ~ x ~ y = ( x / y , x mod y ) ;; val divmod : x : int -> y : int -> int * int = < fun > # divmod ~ x : 4 ~ y : 3 ;; - : int * int = ( 1 , 1 ) # divmod ~ y : 3 ~ x : 4 ;; - : int * int = ( 1 , 1 )Az OCaml-ben kihagyhatja az értékeket a címkézés használatával, ha a paraméter neve és a változó neve megegyezik [ 10] :
# legyen x = 4 in let y = 3 in divmod ~ x ~ y ;; - : int * int = ( 1 , 1 )
Az OCaml kifejezésekben a műveletek asszociativitását az előtag határozza meg, így a felhasználó által definiált műveletekre is kiterjed. A jel -előtagként és infix műveletként is működik, és szükség esetén a függvénnyel együtt történő előtagként való használathoz a paramétert zárójelek közé kell tenni [12] .
| Műveleti előtag | Az asszociativitás |
|---|---|
| ! ? ~ | Előtag |
| . .( .[ .{ | |
| függvény alkalmazása, konstruktor, címke, assert,lazy | Bal |
| - -. | Előtag |
| ** lsl lsr asr | Jobb |
| * / % mod land lor lxor | Bal |
| + - | Bal |
| :: | Jobb |
| @ ^ | Jobb |
| & $ != | Bal |
| & && | Jobb |
| or || | Jobb |
| , | |
| <- := | Jobb |
| if | |
| ; | Jobb |
| let match fun function try |
Az OCaml nyelvnek több primitív típusa van : numerikus típusok ( egész és lebegőpontos), karakter , karakterláncok , logikai [13] .
Az egész típus a [−2 30 , 2 30 − 1] és [−2 62 , 2 62 − 1] tartományba tartozó egész számokat jelöli 32 bites, illetve 64 bites architektúrák esetén. Az egész számokkal a szokásos összeadás, kivonás, szorzás, osztás műveleteket végezhetjük el, az osztás maradékát figyelembe véve :+,-,*,/,mod. Ha az eredmény túllépi a megengedett intervallumot, akkor nem történik hiba, és az eredményt az intervallum határának megfelelően számítjuk ki [14] .
A lebegőpontos számokat egy 53 bites mantisszával és egy kitevővel ábrázoljuk a [−1022, 1023] intervallumban, követve az IEEE 754 -es kettős szabványt. A műveletekben ezek a számok nem keverhetők egész számokkal. Ezenkívül a lebegőpontos számokkal végzett műveletek szintaktikailag különböznek az egész műveletektől:+.,-.,*.,/.. Van egy hatványozási művelet is:**. Egész számok lebegőpontos számokká konvertálásához és fordítva a következő függvények állnak rendelkezésre: float_of_int és int_of_float [14] .
A lebegőpontos számokhoz további matematikai függvények is léteznek: trigonometrikus (sin, cos, tan, asin, acos, atan), kerekítés (plafon, padló), exponenciális (exp), logaritmikus (log, log10), valamint a négyzetgyök (sqrt) [14] . Vannak polimorf összehasonlító műveletek is numerikus típusokra [14] .
A karaktertípus - char - egy 0 és 255 közötti kóddal rendelkező karakter megjelenítésének felel meg (az első 128 karakter megegyezik az ASCII karakterrel ). Karakterlánc típusa - karakterlánc - karaktersorozat (maximális hossz: 2 24 - 6) [15] . Példa az egész számból karakterláncba konvertáló függvény és az összefűzési művelet használatára :
# "Példa" ^ string_of_int ( 2 ) ;; - : string = "2. példa"A logikai típusnak két értéke van:true(igaz) ésfalse(hamis). Műveletek logikai értékeken: unáris not (negáció), bináris:&&(és),||(vagy). A bináris műveletek először a bal oldali argumentumot értékelik ki, és csak akkor, ha szükséges [16] .
Összehasonlítások eredményeként logikai értékeket kapunk: =(strukturális egyenlőség), ==(identitás), <>(a szerkezeti egyenlőség tagadása), !=(identitás tagadása), <, >, <=, >=. Primitív típusoknál a karakterláncok és a lebegőpontos számok kivételével a szerkezeti egyenlőség és az azonosság egybeesik, más típusoknál a memóriában ugyanazon a címen található értékeket azonosnak tekintjük, szerkezeti összehasonlításban pedig komponensenként ellenőrzik az értékeket. [16] .
Ezen kívül az OCaml rendelkezik egy speciális típusú egységgel, amelynek csak egy értéke van - ()[16] .
ListákAz OCaml -ben a lista azonos típusú elemek véges, változtathatatlan sorozata, amely egyedileg összekapcsolt listaként van megvalósítva. A következő példa a lista szintaxisát mutatja be [17] :
# [ 'a' ; 'b' ; 'c' ] ;; - : char list = [ 'a' ; 'b' ; 'c' ] # 'a' :: ( 'b' :: ( 'c' :: [] )) ;; - : char list = [ 'a' ; 'b' ; 'c' ] # 'a' :: 'b' :: 'c' :: [] ;; - : char list = [ 'a' ; 'b' ; 'c' ] # [] ;; - : ' egy lista = []A művelet ::lehetővé teszi egy lista összeállítását az új elem és a régi lista vége alapján. Ebben az esetben a "régi" lista nem változik:
# legyen lst = [ 1 ; 2 ] ;; val lst : int lista = [ 1 ; 2 ] # legyen lst1 = 0 :: lst ;; val lst1 : int lista = [ 0 ; 1 ; 2 ] # lst ;; - : int lista = [ 1 ; 2 ] # lst1 ;; - : int lista = [ 0 ; 1 ; 2 ] Példa: egy lista elemeinek összegének kiszámításaA lista az OCaml egyik fő adattípusa. A következő kódpélda egy rekurzív (figyelje meg a rec kulcsszót) függvényt definiál, amely egy adott lista elemei fölött iterál, és visszaadja azok összegét:
legyen rec összeg xs = illessze xs -et | [] -> 0 | x :: xs' -> x + összeg xs' #összeg[1;2;3;4;5];; - : int = 15Az összeg kiszámításának másik módja az összesítő függvény használata:
legyen összeg xs = Lista . fold_left (+ ) 0xs # összeg [ 1 ; 2 ; 3 ; 4 ; 5 ];; - : int = 15 BejegyzésekA rekordok fontos elemei az OCaml típusú rendszernek. A rekord egy együtt tárolt értékek halmaza, ahol az értékrekord minden eleme a nevével, a rekord mezőnevével érhető el. Példa típusdeklarációra, egy rekord változóhoz kötése és rekordmező elérése [18] :
# type user = { login : string ; jelszó : string_ _ becenév : string_ _ };; # let usr = { login = "felhasználóm" ; jelszó = "titkos" ; nick = "aka" ; } ;; val usr : user = { login = "saját felhasználó" ; jelszó = "titkos" ; nick = "aka" } # usr . Nick ;; - : string = "más néven"Megjegyzendő, hogy az usr változó típusát a fordító automatikusan beállította.
A többi típushoz hasonlóan egy típus is paraméterezhető. Egyéb rögzítési lehetőségek [18] :
A változattípus olyan adatokat jelent, amelyek különféle formákat ölthetnek, kifejezett címkékkel meghatározva. A következő példa az alapszínek típusát határozza meg [19] :
# type fő_szín = Piros | zöld | kék ;; # kék ;; - : fő_szín = Kék # ( Piros , Kék ) ;; - : fő_szín * fő_szín = ( piros , kék )A fenti példában a változattípus szerepel felsorolt típusként . Az OCaml-ben viszont a variáns típus gazdagabb, mert a címkék mellett adatok megadását is lehetővé teszi, pl.
# type_color_scheme = RGB of int * int * int | _ CMYK of float * float * float * float ;; type_color_scheme = RGB of int * int * int | _ CMYK of float * float * float * floatA függvények meghatározásakor a variánstípus természetesen párosul a mintaillesztéssel.
ObjektumokAz OCaml-ben az objektumok és típusaik teljesen elkülönülnek az osztályrendszertől . Az osztályok objektumok létrehozására és az öröklődés támogatására szolgálnak, de nem objektumtípusok. Az objektumoknak saját objektumtípusuk van , és nem kell osztályokat használnia az objektumokkal való munkavégzéshez. Az objektumokat nem használják olyan gyakran az OCaml-ben (például a modulrendszer kifejezőbb, mint az objektumok, mivel a modulok tartalmazhatnak típusokat, de az osztályok és objektumok nem). Az objektumok fő előnye a rekordokkal szemben, hogy nem igényelnek típusdeklarációt, és rugalmasabbak a sorpolimorfizmus miatt . Másrészt az objektumok előnyei az osztályrendszer használatakor érvényesülnek. A moduloktól eltérően az osztályok támogatják a késői kötést, ami lehetővé teszi az objektum metódusokra való hivatkozást statikusan definiált implementáció nélkül és nyílt rekurzió használatát (modulok esetén használhatunk függvényeket és funktorokat, de szintaktikailag az ilyen leírásokhoz több kódot kell írni) [20 ] .
Típus következtetésBár az OCaml erősen típusos programozási nyelv , a típuskövetkeztető rendszer ( angol type inference ) lehetővé teszi egy kifejezés típusának meghatározását az összetevőiről rendelkezésre álló információk alapján. A paritásfüggvény alábbi példájában nincs megadva típusdeklaráció, de a nyelvi fordító teljes információval rendelkezik a függvény típusáról [21] :
# legyen páratlan x = x mod 2 <> 0 ;; val odd : int -> bool = < fun >A funkcionálisokon kívül a nyelv kötelező programozási eszközöket is tartalmaz: mellékhatásokkal rendelkező függvényeket , változó adatokat, kötelező szintaktikai konstrukciókat, különösen explicit ciklusokat while és for[22] .
A következő példa 11 sort nyomtat a szabványos kimenetre (ez a printf függvény mellékhatása):
i = 0 -tól 10 -ig tegye a Printf parancsot . printf " i =%d \n " kész ;;A következő (meglehetősen mesterséges) példában egy tömb elemeit a helyükre növeljük egy előfeltétel ciklusban. A tömbindexhez egy hivatkozást (ref) használunk, amely a ciklustörzsben növekszik:
# let incr_ar ar = let i = ref 0 in while ! i < tömb . hossz ar do ar .(! i ) <- ar .(! i ) + 1 ; incr én kész ;; val incr_ar : int array -> unit = < fun > # let nums = [| 1 ; 2 ; 3 ; 4 ; 5 |];; érték számok : int array = [| 1 ; 2 ; 3 ; 4 ; 5 |] # incr_ar számok ;; - : egység = () # számok ;; - : int tömb = [| 2 ; 3 ; 4 ; 5 ; 6 |]A mellékhatások lehetővé teszik a számítások optimalizálását, különösen, ha jelentős átalakításokról van szó nagy adathalmazokon. Lusta kiértékelés és memoizálás megvalósítására is használják [22] .
Az OCaml két nyelvből áll: az értékeket és típusokat tartalmazó alapnyelvből, valamint a modulok és aláírásaik nyelvéből . Ezek a nyelvek két réteget alkotnak abban az értelemben, hogy a modulok tartalmazhatnak típusokat és értékeket, míg a normál értékek nem tartalmazhatnak modulokat és típusmodulokat. Az OCaml azonban egy olyan mechanizmust kínál az első osztályú modulokhoz , amelyek értékek lehetnek, és szükség szerint átalakíthatók normál modulokká, illetve normál modulokból [23] .
Az OCaml modulrendszer nem korlátozódik a moduláris kódszervezésre és interfészekre. Az általános programozás egyik fontos eszköze a funktorok . Egyszerűen fogalmazva, a funktorok egy modultól modulig terjedő függvények, amelyek lehetővé teszik a következő mechanizmusok megvalósítását [24] :
Az OCaml nyelvi tolmács elindításához írja be a következő parancsot a konzolon:
$ ocaml OCaml 4.08.1 verzió #A számításokat interaktív módon lehet elvégezni, például:
# 1 + 2 * 3 ;; - : int = 7A következő "hello.ml" program:
print_endline "Hello World!" ;;bájtkódra fordítható :
$ ocamlc hello.ml -o hellovagy optimalizált gépi kódba :
$ ocamlopt hello.ml -o helloés elindult:
$ ./üdv Helló Világ! $A következő példa egy gyorsrendezési algoritmus , amely növekvő sorrendben rendezi a listát:
legyen rec qsort = függvény | [] -> [] | pivot :: rest -> let is_less x = x < pivot in let left , right = List . partíció_less rest in qsort left @ [ pivot ] @ qsort right _Megjegyzés - A könyv az " első osztályú függvény " kifejezést " elsőrendű függvényként " használja. De szem előtt kell tartani, hogy számos angol nyelvű forrásban (a nyelvek szemantikájáról általában, valamint az ML -ről és a Hindley-Milnerről különösen) négy fogalmat különböztetnek meg fogalmilag:
ráadásul az „ első osztályú ” „ jobb ”, mint a „ másodosztályú ” (képességeiben szélesebb, közelebb áll az elmélethez és magasabb a belépési küszöb tekintetében ( C. Strachey – Fundamental Concepts in Programming Languages )), de „ elsőrendű ” primitívebb, mint a „ magas rendű ”. Különösen az ML modul nyelvének kiterjesztése az „ első osztályú magasrendű ” szintre sokkal nagyobb problémát jelent a kutatók számára, mint annak kiterjesztése csak „ első osztályúra ” vagy csak „ magas rendűre ” ( Rossberg A. Functors and futásidejű vs fordítási idő (lefelé irányuló kapcsolat) Letöltve: 2015. június 25. Az eredetiből archiválva : 2015. június 26. ).
| Programozási nyelvek | |
|---|---|
| |