Discussion :

[bbertrand]

Bonsoir,

J'aimerais retranscrire en Haskell les définitions ci dessous ( code Scala )

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
type Set = Int => Boolean
def contient(s: Set, elem: Int): Boolean = s(elem)
def singl (elem: Int): Set = (n: Int) => n == elem
def union(s: Set, t: Set): Set = (n: Int) => s(n) || t(n)

1) Définition du type ensemble ( de nombres entiers ) en tant que fonction ( dans Boolean )
2) Définition de l'inclusion
3) Définition d'un singleton {elem}
4) Définition de l'union

Pour les 3 premières étapes, je propose

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
type Set = (Int -> Bool)
 
contient :: Set -> Int -> Bool
contient set el = set el
 
singl :: Int -> Set 
singl ele = (== ele)

ce qui marche bien, comme on peut le vérifier :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

contient (singl 2) 3

False

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

contient (singl 2) 3

True

Par contre je n'arrive pas à définir l'union, j'ai essayé :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
union :: (Set -> Set) -> Set
union s1 s2 = (λn -> (contient s1 n)||(contient s2 n) )

ce qui donne le message d'erreur :
Pattern syntax in expression context: λn -> (contient s1 n) || (contient s2 n)

Le problème est que je ne connais pas l'équivalent de "(n: Int) => " de Scala, qui introduit un entier n quelconque.

Merci d'avance si vous avez une idée...

[Jedai]

Par contre je n'arrive pas à définir l'union, j'ai essayé :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
union :: (Set -> Set) -> Set
union s1 s2 = (λn -> (contient s1 n)||(contient s2 n) )

ce qui donne le message d'erreur :
Pattern syntax in expression context: λn -> (contient s1 n) || (contient s2 n)

Le problème est que je ne connais pas l'équivalent de "(n: Int) => " de Scala, qui introduit un entier n quelconque.

Merci d'avance si vous avez une idée...

Ton équivalent λn est tout à fait valable (quoique sans unicode, on l'écrit juste "(\n -> ...)" ). Le problème n'est pas là, comme te le dit GHC, tu essaies de mettre un pattern comme argument de fonction là où les types dicteraient que tu ais une expression (qui ne soit pas une fonction), plus précisément une expression booléenne... "Mais", vas-tu me dire, "Set est une fonction qui renvoie un booléen, pas juste un booléen ! Et ma fonction renvoie Set."

En fait non, le problème réside précisément dans le type de ta fonction :
union :: (Set -> Set) -> Set = union :: (...) -> Int -> Bool
Autrement dit, vu les parenthèses ta fonction prend 2 arguments : s1 de type (Set -> Set) et s2 de type Int et renvoie un Bool !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
union :: Set -> Set -> Set
union s1 s2 = (\n -> s1 n || s2 n)

marche parfaitement.

(->) associe vers la droite donc ce type est équivalent à "Set -> (Set -> Set)" autrement dit une fonction qui prend un Set et renvoie une fonction de type "Set -> Set" qui prend un Set et renvoie un Set. Donc si tu lui donnes 2 Set, tu obtiens un Set. Il s'agit là de curryfication, un concept qui n'est pas toujours utilisé en Scala. Tu pourrais aussi avoir quelque chose de plus proche de langages plus classiques en écrivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
union :: (Set, Set) -> Set
union(s1, s2) = (\n -> s1 n || s2 n)

Mais la version curryfiée est préférable aussi bien d'un point de vue d'usage courant du Haskell que d'un point de vue pratique.

Bonne continuation.
--
Jedaï

[bbertrand]

Merci beaucoup Jedaï.

J'ai compris mon erreur, ainsi que l'avantage de la version curryfiée.
La programmation fonctionnelle a un charme particulier.
Que la force reste avec toi