IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Haskell Discussion :

Definir des ensembles à partir de fonctions


Sujet :

Haskell

  1. #1
    Membre à l'essai
    Homme Profil pro
    Enseignant
    Inscrit en
    décembre 2014
    Messages
    34
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 58
    Localisation : Suisse

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : décembre 2014
    Messages : 34
    Points : 20
    Points
    20
    Par défaut Definir des ensembles à partir de fonctions
    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 :

    False

    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...

  2. #2
    Expert éminent
    Avatar de Jedai
    Homme Profil pro
    Enseignant
    Inscrit en
    avril 2003
    Messages
    6 245
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Côte d'Or (Bourgogne)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : avril 2003
    Messages : 6 245
    Points : 8 560
    Points
    8 560
    Par défaut
    Citation Envoyé par bbertrand Voir le message
    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ï

  3. #3
    Membre à l'essai
    Homme Profil pro
    Enseignant
    Inscrit en
    décembre 2014
    Messages
    34
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 58
    Localisation : Suisse

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : décembre 2014
    Messages : 34
    Points : 20
    Points
    20
    Par défaut
    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

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Creer des fichier latex a partir de fonction C++
    Par Nono Sto dans le forum Débuter
    Réponses: 0
    Dernier message: 24/04/2010, 17h43
  2. extraire des ensembles d'objets a partir d'un nuage de points
    Par salihovic dans le forum Traitement d'images
    Réponses: 21
    Dernier message: 10/11/2009, 12h07
  3. Dérivation à partir des valeurs d'une fonction
    Par haley dans le forum MATLAB
    Réponses: 5
    Dernier message: 11/03/2009, 20h18
  4. [MySQL] Traitement de Formulaire : générer des ensemble à partir d'une boucle foreach
    Par yodaazen dans le forum PHP & Base de données
    Réponses: 2
    Dernier message: 05/10/2006, 15h28
  5. Remplir des listes à partir d'appels de fonction
    Par nickoko dans le forum Général JavaScript
    Réponses: 4
    Dernier message: 18/07/2006, 10h17

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo