Syntaxe Haskell - Syntaxe C

(1)

Syntaxe Haskell - Syntaxe C

if e

₁

^then e

₂

^else e

₃

^if (e

₁

) {e

₂

; } ^else {e

₃

; } e

₁

? e

₂

: e

₃

f x y = e

type_e

f (

type_x

x,

type_y

y ) {e; }

let x = e

₁

ⁱⁿ e

₂

{

type_x

x = e

₁

; e

₂

; }

(2)

Types en C

•

int, char, short, long, ...

•

float, double, ...

•

enum

•

pointeurs, tableaux, ...

•

void

•

struct

•

union

•

fonctions

(3)

Un datatype en C

data Type = Atom | Tup Type Type | Arrow Type Type

typedef struct type type;

struct type {

enum { ATOM, TUP, ARROW } tag;

union {

char *atom;

struct { type *t[2]; } tup;

struct { type t1, t2; } arrow;

} v;

};

(4)

Un datatype en C, suite

#define XTUP(t) ((t)->v.tup)

type type_tup (type t1, type *t2) {

type *t = malloc (sizeof (type));

t->tag = TUP;

XTUP (t).t[0] = t1;

XTUP (t).t[1] = t2;

return t;

}

(5)

De l’assembleur au C

registres

= ⇒

variables adresses

= ⇒

pointeurs +struct

+union

+programmation structur ´ee

(6)

Programmation imp ´erative

M ême mod èle que la machine: s équence d’op érations sur la m émoire Les fonctions (qui construisent un r ésultat) sont remplac ées par des proc édures (qui op èrent par modification de leurs arguments).

Concepts reli ´es:

•

s équence: suite d’op érations à effectuer dans un ordre particulier, avec des d épendences implicites

•

´etat: ce qui peut changer avec le temps

•

effet de bord: modification apport ´ee par une op ´eration

•

identit ´e: ce qui distingue un objet d’une copie identique

•

valeur: objet sans identit ´e

(7)

Structure m ´emoire

La m émoire est compos ée d’un graphe d’objets M émoire = un ensemble d’objets

Objet = une s ´equence de bytes

•

Code: ensemble de fonctions et proc ´edures

•

Pile: ensemble ordonn é d’objets cr é és implicitement

•

Tas: ensemble non-ordonn é d’objets cr é és explicitement

(8)

Proc ´edures

Une fonction ou proc édure est un fragment de programme clairement d élimit é

La signature ou interface d’une fonction est son type Le corps d’une fonction est le code en soi

Une d ´efinition de fonction donne son corps, sa signature, la liste des param `etres formels

Un appel de fonction indique la fonction et les param `etres actuels

(9)

Passage de param `etres

Lien entre un param `etre formel et un param `etre actuel

•

par valeur (le plus r ´epandu)

•

par nom (Algol, Haskell)

•

par r ´ef ´erence (Pascal, C++, Modula-2)

•

par valeur-r ´esultat (Ada)

(10)

Passage par valeur

Le syst `eme le plus simple:

Le param ètre formel est une nouvelle variable, initialis ée avec une copie de la valeur du param ètre actuel

Les modifications faites sur le param `etre formel n’affectent pas le param `etre actuel

I.e. l’appel ´e ne peut pas avoir d’effet sur l’appelant

(11)

Passage par nom

Le param ètre actuel est une expression pass ée sans être évalu ée Le param ètre formel fait r éf érence à l’expression

Chaque usage du param `etre formel cause l’ ´evaluation de l’expression

(12)

Passage par r ´ef ´erence

Le param ètre actuel est un emplacement m émoire Le param ètre formel d ésigne le m ême emplacement

PROCEDURE inc (VAR x : integer) BEGIN

x = x + 1;

END

... inc (z); inc (y[3]); ...

On peut parfois le simuler en passant par valeur une r ´ef ´erence:

void inc (int x) { x = *x + 1; }

... inc (&z); inc (y+3); ...

(13)

Passage par valeur-r ´esultat

A mi-chemin entre passage par valeur et passage par r éf érence Le param ètre actuel est un emplacement m émoire

le param ètre formel est une nouvelle variable initialis ée avec la valeur contenue dans l’emplacement m émoire

Lorsque la fonction termine, la valeur du param ètre formel est copi ée dans l’emplacement du param ètre actuel

On peut aussi le simuler en passant par valeur une r ´ef ´erence:

void inc (int *xp)

{ int x = xp; x = x + 1; xp = x; }

... inc (&z); inc (y+3); ...

(14)

Alias

alias: deux mani ère diff érentes de nommer une m ême entit é

Example:

FUNCTION foo (VAR a : INTEGER) BEGIN ... END ... foo (b); ...

Ou encore:

XAPP (e1).f = XTUP (e2).e1;

Ou encore:

let x = (snd y, y) in ...

(15)

Alias, suite

Une modification sur un objet affecte imm édiatement tous ses alias Peut- être tr ès utile

Mais c’est aussi une source de probl `emes difficiles

Sans alias, passage par r ´ef ´erence

≡

passage par valeur-r ésultat La notion d’alias est intimement li ée à celle de pointeur

int foo (int x[], int y[]) { x[0] = 1;

y[0] = 2;

return x[0] + y[0]; }

(16)

Pointeurs et r ´ef ´erences

Tout probl ème peut être r ésolu en ajoutant un niveau d’indirection Utilis és de mani ère interne par les compilateurs

Utilis ´es pour les structures de donn ´ees plus complexes que les tableaux et les enregistrements

Taille fixe (petite) ind épendante de l’objet r éf érenc é Utilis é aussi pour éviter des copies co ûteuses

∗x '

mem

[x]

(17)

Op ´erations sur les pointeurs

Op ´erations principales:

•

Allocation d’un objet, renvoie un nouveau pointeur sur un espace m ´emoire jusqu’alors inutilis ´e

•

Indirection, pour acc éder à l’objet point é par le pointeur

•

R écup ération de l’espace allou é Autres op érations parfois support ées:

•

Arithm ´etique:

p + n

,

p

₁

− p

₂, ...

•

Obtention d’un pointeur sur un objet existant:

&x

(18)

Arithm ´etique sur les pointeurs

En C, on peut additionner un pointeur et un entier

∗(x + n) '

mem

[x + n ∗ k]

C’est utilis ´e pour les tableaux:

x[n] ≡ ∗(x + n) ≡ ∗(n + x) ≡ n[x]

Si

x

pointe sur un tableau de taille 10, la valeur de

x + 11

est ind ´efinie On peut aussi faire la diff ´erence entre 2 pointeurs:

(x + n) − x == n

La valeur de

x

₁

− x

₂ n’est pas d ´efinie si

x

₁ et

x

₂ pointent dans des objets diff ´erents

(19)

Structures de contr ˆ ole

flux/flot de contr ôle = trajet suivi par le point d’ex écution flux/flot de donn ée = trajet suivi par les donn ées

•

Sauts:

goto

,

break

,

continue

, ...

•

Tests:

if

,

case

, filtrage,

? :

,

&&

,

||

, ...

•

Boucles:

for

,

while

,

loop

, ...

•

Fonctions

•

Exceptions

•

Non-d ´eterminisme

(20)

Fonctions d’ordre sup ´erieur

Les fonctions d’ordre sup érieur permettent de cr éer de nouvelles structures de contr ôle

fun

_for

a b f =

if a > b ^then ()

else (f a;

for

(a + 1) b f ) . . .

for

1 10 ( ^fn i ⇒

print

(

Int.toString

i))

(21)

Programmation structur ´ee

L’usage abusif de

goto

m `ene `a des programmes spaghetti

La programmation structur ´ee impose des r `egles qui assurent une

certaine correspondance entre la structure syntaxique d’un programme et son flot de contr ˆole

Structuration stricte: un point d’entr ´ee et un point de sortie Structuration laxiste: un point d’entr ´ee

(22)

Le switch de C

L’ énonc é switch de C n’est pas tr ès structur é

void copier (char src, char dst, int n) { while (n > 0) { dst++ = src++; n--; } }

void copier (char src, char dst, int n) { switch (n & 3) {

case 0: while (n > 0) { dst++ = src++;

case 3: dst++ = src++;

case 2: dst++ = src++;

case 1: dst++ = src++;

n -= 4;

} } }

(23)

R ´ecursion

La r écursion est une forme g én éralis ée de boucle

void toto ()

{

int c, fdl;

fdl = TRUE;

while ((c = getchar ()) != EOF) { if (c == ’\n’) {

if (fdl) continue;

fdl = TRUE;

} else

fdl = FALSE;

putchar (c);

(24)

R ´ecursion (suite)

void toto_1 (int fdl) {

int c;

if ((c = getchar ()) != EOF) { if (c == ’\n’) {

if (fdl) continue;

fdl = TRUE;

} else

fdl = FALSE;

putchar (c);

toto_1 (fdl);

} }

(25)

R ´ecursion (continue)

if ((c = getchar ()) != EOF) { if (c == ’\n’ && fdl)

toto_1 (fdl);

else {

if (c == ’\n’) fdl = TRUE;

} else

fdl = FALSE;

putchar (c);

toto_1 (fdl);

} }

(26)

R ´ecursion (nettoyage)

void toto_1 (int fdl) {

int c = getchar ();

if (c != EOF) {

if (c == ’\n’ && fdl) toto_1 (TRUE);

else {

putchar (c);

toto_1 (c == ’\n’);

} } }

void toto () { toto_1 (TRUE); }

(27)

R ´ecursion (fin)

void toto_1 (int fdl) {

int c = getchar ();

if (c != EOF) {

if (c != ’\n’ || !fdl) putchar (c);

toto_1 (c == ’\n’);

} }

void toto () { toto_1 (TRUE); }

(28)

Repr ´esentation des objets scalaires

Les objets tels que: pointeurs, entiers, caract `eres, bool ´eens,

enum

, nombres `a virgule flottante, ...

G éneralement trait és de mani ère atomique Pas de notion d’identit é

Repr ´esent ´es par un nombre fixe de bits

Contraintes d’alignement, soit impos ´ees par l’architecture, soit n ´ecessaires pour des raisons de performance

Alignement naturel = adresse est un multiple de la taille de l’objet

(29)

Repr ´esentation des tableaux

Noms: tableaux, vecteurs

Disposition contigu ¨e en m ´emoire

Chaque él ément du tableau a la m ême taille adresse de

T [i] =

base

+ (i −

min

) ×

size

Selon les langages, la repr ´esentation peut ou non contenir un champ suppl ´ementaire qui indique la taille totale du tableau

Sans ce champ suppl émentaire le compilateur ne peut pas v érifier les d épassements de bornes

(30)

Repr ´esentation des structures

Les noms varient: structures, enregistrements, objets, tuples, ...

Dispositions contigu ¨e des champs en m ´emoire:

record

a : char; (* adr relative = 0 *)

b1,b2 : integer; (* adr relative = 1 et 5 ) c : real; ( adr relative = 9 *)

end

En r éalit é, du padding sera ajout é pour aligner le champ

b1

_{, donc}

l’adresse relative de

b1

,

b2

, et

c

sera respectivement 4, 8, et 12 Du padding peut ausi être ajout é à la fin

(31)

Effets de bord en Haskell

Probl `eme:

•

D éterminer si une expression est évalu ée, combien de fois, et dans quel ordre, peut être tr ès difficile en Haskell.

•

Heureusement, cela ne change rien au r ´esultat.

•

Par contre, cela rend les effets de bord inutilisables.

Solution: main renvoie une liste de commandes `a ex ´ecuter.

L’ex ´ecution de ces commandes est faite “en dehors”.

IO τ

: type d’une commande qui renverra une valeur de type

τ

.

(32)

Entr ´ees sorties en Haskell

getChar :: IO Char

putChar :: Char -> IO ()

L’op ´erateur

>>=

permet de composer les op ´erations:

(>>=) :: IO a -> (a -> IO b) -> IO b

getChar >>= (\c -> putChar (succ c)) :: IO ()

Cela s’ ´ecrit habituellement avec le sucre syntaxique

do

:

do c <- getChar

putChar (succ c)

(33)

Affectations en Haskell

En plus de toutes les structures de donn ées pures, Haskell a aussi des cellules sp éciales que l’on peut modifier à loisir:

newIORef :: a -> IO (IORef a) readIORef :: IORef a -> IO a

writeIORef :: IORef a -> a -> IO ()

newIORef v

cr ée une nouvelle cellule muable initialis ée à

v readIORef r

lit le contenu de la cellule

r

writeIORef r v

affecte `a la cellule

r

la valeur

v

(34)

Distinguer une commande et son ex ´ecution

La partie pure du langage est s ´epar ´ee de la partie impure

a = map putChar [’a’, .. ’z’]

b = (a,a)

c = putChar ’1’

main = head (snd b)

a

est une liste de commandes

b

est une paire de 2 listes de commandes Le programme imprime seulement “

a

”

(35)

Monads et effets

IO

_{est un} _monad

•

Il y en a beaucoup d’autres (ST, Maybe, Cont, Parser, List, STM, ...)

•

Le monad indique quel genre d’effet peut ˆetre pr ´esent dans la commande correspondante.

Dans les langages imp ´eratifs, il existe un concept similaire: les syst `emes d’effets

•

Chaque function est annot ´ee avec les effets qu’elle peut avoir

•

E.g.

τ

₁

→

τ

₂ o `u les effets de bords sont d ´ecrits par

•

Les effets peuvent inclure la liste des exceptions potentiellement lev ées, les r égions utilis ées, ...

Syntaxe Haskell - Syntaxe C