Bonjour,

Je suis en train d'apprendre l'Haskell et je suis à la résolution d'un exercice dont, 1, je ne comprend pas le sens d'un mot dans l'énoncé et, 2, je n'arrive pas à trouver de "belle" solution pour celui-ci.

Voici l'énoncé (c'est en anglais mais si vous voulez je peux le traduire ) :

Exercise 4.6 Write a datatype Tuple which can hold one, two, three or four elements,
depending on the constructor (that is, there should be four constructors, one for each
number of arguments). Also provide functions tuple1 through tuple4 which take a
tuple and return Just the value in that position, or Nothing if the number is invalid
(i.e., you ask for the tuple4 on a tuple holding only two elements).

C'est le mot en gras qui me pose problème : est-ce vraiment "tuple" ou est-ce "Tuple" ?


Sinon, en considérant que c'est Tuple :

data Tuple a b c d = One a
                   | Two a b
                   | Three a b c
                   | Four a b c d

tuple1 :: (Tuple a b c d) -> Maybe a
tuple1 -- et puis je ne vois pas...

Je ne vois pas comment tester quel constructeur a été utilisé !

Merci

PS : le lien du tuto, page 60 du pdf

Pour le tuple / Tuple, c'est du pinaillage, c'est la même chose. Faut utiliser ton type.

Sinon, je ne connais pas du tout Haskell (enfin, très peu), mais pour tuple3, ça donnerait par exemple ceci en mix moche OCaml/Haskell, si j'ai bien compris l'énoncé :

let tuple3 t = match t with
|   One a -> Nothing
|   Two (a, b) -> Nothing
|   Three (a, b, c) -> c
|   Four (a, b, c, d) -> d

J'avoue que c'est du pinaillage ^^, mais si c'est un simple tuple, il faudrait prévoir une infinité de cas : si on reçoit un tuple vide ou contenant 1, 2, ..., n éléments. Non ?

Ceci dit, je n'ai aucune idée de ce que veut dire match et with : à ce stade du tutoriel on n'a pas encore vu ça

Citation : ibizaman

Ceci dit, je n'ai aucune idée de ce que veut dire match et with : à ce stade du tutoriel on n'a pas encore vu ça

C'est pas de l'Haskell mes match/with, c'est juste pour t'expliquer le principe. Je connais pas du tout la syntaxe Haskell pour ce genre de trucs.

Sinon ouais, si on te fait définir un type Tuple, il me parrait logique que c'est pour l'utiliser après .

Citation : wgmpgp

C'est pas de l'Haskell mes match/with, c'est juste pour t'expliquer le principe. Je connais pas du tout la syntaxe Haskell pour ce genre de trucs. .

C'est justement ça qui me manque !

Mais je suppose qu'on peut faire l'exercice avec ce qu'on a déjà vu dans le tutoriel

Bon, trouvé :

tuple3 :: (Tuple a b c d) -> Maybe a
tuple3 (One a) = Nothing
tuple3 (Two a b) = Nothing
tuple3 (Three a b c) = Just a
tuple3 (Four a b c d) = Just a

... preuve que j'avais pas tout compris puisque le "problème" avait été résolu dans le tuto

Merci

Si tu veux gérer des "tuples de taille quelconque", il te faut en fait des listes. La fonction serait de type ([a] -> Int -> Maybe a), elle existe presque dans la bibliothèque standard (c'est (!!), à utiliser liste !! n), mais est de type ([a] -> Int -> a), et renvoie une erreur si l'indice est supérieur à la taille de la liste.

Dites, j'ai encore un petit problème à l'exercice suivant :

Exercise 4.7 Based on our definition of Tuple from the previous exercise, write a
function which takes a Tuple and returns either the value (if it’s a one-tuple), a
Haskell-pair (i.e., (’a’,5)) if it’s a two-tuple, a Haskell-triple if it’s a three-tuple
or a Haskell-quadruple if it’s a four-tuple. You will need to use the Either type to
represent this.

Donc cette fois on transforme un Tuple en tuple.

J'arrive à :

data My_Either a b c d = EOne a
                       | ETwo (a,b)
                       | EThree (a,b,c)
                       | EFour (a,b,c,d)

tuple :: (Tuple a b c d) -> My_Either a b c d
tuple (One a) = EOne a
tuple (Two a b) = ETwo (a,b)
tuple (Three a b c) = EThree (a,b,c)
tuple (Four a b c d) = EFour (a,b,c,d)

Mais il y a deux, trois trucs qui me turlupinent :
Faut-il vraiment définir son propre Either ?
En fait je ne répond pas à la question ! On doit renvoyer un tuple et je renvoie un My_Either ???

Comment faire pour avoir un type de fonction comme ceci :

tuple :: (Tuple a b c d) -> a
tuple :: (Tuple a b c d) -> (a,b)
tuple :: (Tuple a b c d) -> (a,b,c)
tuple :: (Tuple a b c d) -> (a,b,c,d)
-- plutôt que :
tuple :: (Tuple a b c d) -> My_Either a b c d

Je ne crois pas que cela soit possible mais je ne vois vraiment pas comment renvoyer un "Haskell-tuple" ?

À la rigueur, tu pourrais faire des Either imbriqués, soit :

tuple :: (Tuble a b c d) -> Either (Either a (a, b) (Either (a, b, c) (a, b, c d))

Mais toutes les solutions que je vois sont moches.

Pareil !

Merci quand même

La solution par My_Either est clairement fausse, vu que c'est un type évidemment isomorphe (~ identique) à ton Tuple. C'est la solution de GuilOooo qui est à retenir, sachant que pour ma part je privilégierais le typage suivant (entre autres parce qu'il est plus lisible, bien que moins équilibrée) :
Either a (Either (a, b) (Either (a, b, c) (a, b, c, d)).

Par ailleurs, étant donné que les "question scolaires" sont "interdites" depuis peu, si tu pouvais faire semblant de juste poser des questions intéressantes au lieu de nous faire faire tes exercices, ce serait encore mieux.

Citation : bluestorm

Par ailleurs, étant donné que les "question scolaires" sont "interdites" depuis peu, si tu pouvais faire semblant de juste poser des questions intéressantes au lieu de nous faire faire tes exercices, ce serait encore mieux.

Hum, d'ailleurs je me souviens pas, on doit remercier qui pour ça ?

Faut savoir, d'habitude le gars qui demande de faire l'exercice ne propose jamais sa solution alors on le lui reproche et on lui dit essaye puis on t'aidera.
Et quand le gars essaye on lui dit que sa question est débile.

Si ça ne te plais pas de répondre à ma question, tu peux ne pas y répondre ...

Sauf que c'est tout sauf scolaire...

Ce sont les exercices d'un des principaux tutoriels disponibles sur Haskell
http://en.wikibooks.org/wiki/Haskell/Y [...] _Constructors

Ou alors si c'est scolaire, faut mettre le prof a la porte, copier coller une question d'un tuto, c'est vraiment du foutage de gueule

Non mais hum, cherchez pas, bluestorm fait parti de la haute.
Pour lui ça n'a rien d'inhabituel qu'un prof soit l'auteur d'un bouquin. *





(*) : On me signale dans mon oreillette, que pour lui faire et dire des trucs complètement débiles ça n'a rien d'inhabituel non plus.
Pour ceux qui seraient perdu, cf cas |){-|_|2[]-|-/-/ sur #s

J'ai loupé un épisode, quel est le rapport avec who-must-not-be-named?

Citation : Maxibolt

J'ai loupé un épisode, quel est le rapport avec who-must-not-be-named?

Il fait juste allusion à sa jalousie car celui-dont-on-ne-doit-pas-prononcer-le-nom est op sur #sdz et pas lui, car bluestorm en a décidé ainsi. Donc en fait, pour lui, ça doit être un genre d'argument.

On parle du même sinistre personnage revenu d'entre les bannis sous une fausse identité ?

Oui Metzgermeister, celui dont le pseudo est imprononçable pour la simple raison qu'étant donné que c'était son Xe compte crée dans la journée il a simplement recopié le captcha.

Et sinon, plutôt que de parler de jalousie maladive, disons simplement qu'un mec qui ne passe jamais sur le chan décide de nommer un tel idiot op c'est un bon exemple d'action irréfléchie.

Et... C'est quoi cette histoire ?
Enfin, j'en entend toujours parler de ce gars et j'ai toujours remarqué que bluestorm l'aimait pas... Mais quelqu'un connaît l'histoire ou c'est "secret" ?

Pour en revenir au problème, j'ai essayé ça :

tuple :: (Tuple a b c d) -> Either ( (Either a (a,b)) (Either (a,b,c) (a,b,c,d)) )
tuple (One a) = Left (Left a)
tuple (Two a b) = Left (Right (a,b))
tuple (Three a b c) = Right (Left (a,b,c))
tuple (Four a b c d) = Right (Right (a,b,c,d))

Mais j'ai cette erreur-là :

Kind error: `Either a (a, b)' is applied to too many type arguments
In the type `(Either a (a, b)) (Either (a, b, c) (a, b, c, d))'
In the type `Either ((Either a (a, b)) (Either (a, b, c) (a,
                                                          b,
                                                          c,
                                                          d)))'
In the type `(Tuple a b c d)
             -> Either ((Either a (a, b)) (Either (a, b, c) (a, b, c, d)))'

Ca veut dire quoi "Either a (a, b)' is applied to too many type arguments" ?

C'est un simple problème de parenthèsage :

Either ( (Either a (a,b)) (Either (a,b,c) (a,b,c,d)) )

est faux, il faut utiliser :

Either (Either a (a,b)) (Either (a,b,c) (a,b,c,d))

L'erreur qui t'es signalée veut dire que haskell a parsé comme (E ((E .. ..) (E .. ..))), ce qui est équivalent à E (E .. .. (E .. ..)), donc le deuxième Either a trois arguments au lieu de deux (et le premier un seul).

Evidemment -_-'

Citation : Dark-Side

Oui Metzgermeister, celui dont le pseudo est imprononçable pour la simple raison qu'étant donné que c'était son Xe compte crée dans la journée il a simplement recopié le captcha.

Tiens c'est marrant, j'avais des doutes la dessus, maintenant j'en ai plus

ibizaman -> on aimerait bien en parler mais c'est pas possible, va demander sur #sdz (ou #python) ou par mp à la personne en question.