Viquipèdia

Hume (llenguatge de programació)

llenguatge de programació

Hume (Higher-order Unified Meta-Environment, ‘meta-entorn unificat d'ordre superior’) és un llenguatge de programació funcional i tipificació forta per a sistemes amb recursos limitats que incorpora elements per assegurar l'execució acotada en temps i espai.[1]

Infotaula de llenguatge de programacióHume
Tipusllenguatge de programació Modifica el valor a Wikidata
Data de creació2000 Modifica el valor a Wikidata
Paradigma de programacióprogramació funcional Modifica el valor a Wikidata

Hume ha estat desenvolupat a la Universitat de Saint Andrews, Escòcia. Amb el nom volen retre homenatge a David Hume, filòsof escocès famós pel seu escepticisme que requeria reiterades proves i bons fonaments per arribar a donar crèdit a les formulacions.

Tanmateix és un treball en-procés, amb parts importants (temporitzadors, excepcions) pendents d'implementar en el compilador, malgrat que funcionin en part en l'intèrpret (més endarrerit en altres aspectes i pres com a demostrador de conceptes).

Característiques modifica

 
Estàtua de Hume a Edinburgh

Hume incorpora concurrència per pas de missatges amb sincronització per encaix de patrons, de manera semblant al Join calculus de JoCaml.[2]

Cada autòmat (clàusula box) presenta una seqüència d'encaixos de patrons sobre una tupla de canals d'entrada. En comptes d'especificar els canals i valors com en altres implementacions del Join calculus, s'especifica un encaix de valors per tota la tupla d'entrada, indicant amb un asterisc els canals ignorats (no consumits).

A cada encaix, amb disponibilitat síncrona dels canals, s'associa un procés que retorna una tupla de sortida de missatges opcionals, especificant asterisc per als no generats.

La instrucció wire (cablejat) descriu els canals destinataris dels missatges de la tupla de sortida, així com la procedència dels missatges i inicialització de la tupla de canals d'entrada.

L'estat d'un autòmat queda en els canals realimentats amb sortides pròpies. L'estat del sistema és el del conjunt de bústies dels canals.

El planificador es basa en un bucle infinit d'avaluació d'autòmats blocant els que no puguin col·locar missatges de sortida a bústies ocupades.[3]

Incorpora excepcions a nivell d'autòmat i global per acotar els cicles en temps (de moment només va a l'intèrpret) i en espai (només al compilador) de l'allotjament dinàmic (HeapOverflow) i de sobreiximent de la pila (StackOverflow), a banda de poder definir excepcions pròpies.

Incorpora un llenguatge d'expressions funcional amb la sintaxi del Haskell però semàntica estricta (avaluació primerenca i ordenada dels operands) (">> Like Standard ML, Hume expressions follow a strict evaluation order"), amb suport de funcions d'ordre superior.

Incorpora un metallenguatge de macros/plantilles que permet generar rèpliques dels autòmats i de les connexions.

Capes del Hume modifica

Segons el Hume Report,[4] s'identifiquen una sèrie de nivells:

HW-Hume
una capa de descripció del maquinari capaç de descriure circuits, siguin síncrons o asíncrons, amb encaixos de patrons per a tuples de bits.
FSM-Hume
(FSM: màquina d'estats finits) un llenguatge hard/soft -- HW-Hume més funcions de primer ordre, més condicionals i definicions locals.
Template-Hume
un llenguatge per a la programació expressada en plantilles. -- FSM-Hume més funcions de primer ordre predefinides, polimorfisme i estructures de dades inductives sense incloure funcions definides per l'usuari.
PR-Hume
Template-Hume més funcions i estructures de dades definides per l'usuari.
Full-Hume
Un llenguatge Turing-complet: PR-Hume més recursió sense restriccions a funcions i estructures definides per l'usuari.

Exemples modifica

Exemple per a l'intèrpret: 

 {- fitxer fibo-i.hume
 -}

 -- declaracions

 type Int = int 32 ;

 exception EIncreible :: (Int, string) ;
 exception EArgumentIlegal :: string ;

 -- funcions i símbols (avaluació primerenca)

 fibo :: Int -> Int ;

 fibo 0 = 1;
 fibo 1 = 1;
 fibo n = if n < 0 then raise EArgumentIlegal ("fibo: argument negatiu: " ++ (n as string))
 else fibo (n-1) + fibo (n-2);

 -- fibo acotat en temps

 bfibo :: Int -> Int ;
 bfibo n = (fibo n) within 10ms; -- restricció a 10 ms. dispara Timeout () (només va a l'intèrpret)

 -- autòmat -- l'estat és a les bústies realimentades

 box fib
 in (n::integer, flag_in::integer) -- bústies d'entrada
 out (nextn::integer, flag_out::integer, result::(integer, integer, string)) -- sortides
 -- within 500KB (400KB) -- acotacions del munt d'allotjament de mem. dinàmica (ang: heap)
 -- i entre parent. de la pila (sols per la versió compilador)
 -- -- dispararien excepcions HeapOverflow, StackOverflow
 handles Timeout, EIncreible, EArgumentIlegal -- declaració excep. processades

 match -- (guardes -> accions) a l'estil dels llenguatges CSP
 -- * : opcionalitat (sortides ignorades o entrades no consumides)

 -- ''patró_del_tipus_de_la_clàusula_in'' -> ''expressió_del_tipus_de_la_clàusula_out''

 (n, 0) -> if n >= 99 then raise EIncreible (n, " ates") -- atès (de atényer) vull dir (no admet accents)
 else (n+1, 0, (n, bfibo n, "\n"))
 | (n, 1) -> (n, 0, (n, *, " disparat Timeout\n"))
 | (n, 2) -> (n, 0, (n, *, " disparat Increible\n"))

 handle -- gestió d'excepcions (a l'intèrpret; el compilador només imprimeix el nom de l'excepció)

 -- ''patró_de_l_excepció'' -> ''expressió_del_tipus_de_la_clàusula_out''

 Timeout () -> (0, 1, (*, *, "Atrapat temporitzacio, reiniciem n a 0\n"))
 | EIncreible (n, msg) -> (0, 2, (*, *, "Increible: " ++ (n as string) ++ msg ++ ", reiniciem n a 0\n"))
 | EArgumentIlegal msg -> (0, 0, (*, *, "ArgumentIlegal: " ++ msg ++ "\n"))
 ;

 -- connexions (cablejat de sortides a bústies d'entrada)

 stream output to "std_out";

 wire fib -- especificació d'orígens i destinacions
 -- qualificant els canals amb el nom del procés

 -- tupla corresp. a la clàusula ''in'' amb procedència dels canals d'entrada

 (fib.nextn initially 0, fib.flag_out initially 0)

 -- tupla corresp. a la clàusula ''out'' amb canals de destinació dels missatges de sortida

 (fib.n, fib.flag_in, output)
 ;

Interpretació: 

./hume fibo-i.hume

dona com a resultat 

0 1
1 1
2 2
3 3
4 5
5 8
6 13
7 21
8 34
9 55
10 89
11 144
12 233
Atrapat temporitzacio, reiniciem n a 0
0 disparat Timeout
0 1
1 1
2 2
3 3

Referències modifica

  1. ↑ Eekelen, Marko van. Trends in Functional Programming (en anglès). Intellect, 2007. ISBN 978-1-84150-176-5. 
  2. ↑ Join calculus tutorial
  3. ↑ Traduint el Hume a Java(anglès)
  4. ↑ document Hume Report de definició del llenguatge Arxivat 2009-02-28 a Wayback Machine. (anglès)

Enllaços externs modifica

Obtingut de «https://ca.wikipedia.org/w/index.php?title=Hume_(llenguatge_de_programació)&oldid=33288656»