Discussion :

[mimi6060]

bonjour,
j'essaye de faire une fusion de 2 maybe liste avec le ++ mais j'ai les erreures suivant :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/Users/michel/Documents/workspace/2LammensMichelInterpreteurProlog/Setup.hs:65:58:
    Couldn't match expected type ‘[a0]’
                with actual type ‘Maybe Substitution’
    In the first argument of ‘(++)’, namely ‘listsub’
    In the expression: listsub ++ listsub
 
/Users/michel/Documents/workspace/2LammensMichelInterpreteurProlog/Setup.hs:65:58:
    Couldn't match expected type ‘Maybe Substitution’
                with actual type ‘[a0]’
    In the expression: listsub ++ listsub
    In an equation for ‘substition’:
        substition ((V variable), (F nom1 lTerme1)) listsub
          = listsub ++ listsub
 
/Users/michel/Documents/workspace/2LammensMichelInterpreteurProlog/Setup.hs:65:69:
    Couldn't match expected type ‘[a0]’
                with actual type ‘Maybe Substitution’
    In the second argument of ‘(++)’, namely ‘listsub’
    In the expression: listsub ++ listsub
Failed, modules loaded: none.

[Jedai]

Je suppose que Substitution est une liste, un synonyme pour [(..,..)] ?
Dans ce cas, il faut que tu réfléchisses un peu à ce que tu veux obtenir, en particulier :

1. Si tu as Just xs + Nothing ou Nothing + Just xs, veux-tu obtenir Nothing ou simplement le Just xs ?
2. Si tu as Just xs + Just ys veux-tu Just xs ou Just (xs ++ ys) ?

En supposant que les réponses soit 1)"Just xs" et 2)"Just (xs ++ ys)", tu peux utiliser l'opérateur <> (mappend) de Data.Monoid, sinon il va falloir donner des précisions...

Par ailleurs listsub ++ listsub est un peu bizarre... tu veux vraiment avoir deux fois de suite ta liste des substitutions d'origine ?

--
Jedaï

[mimi6060]

j'ai trouver ensuite je devais faire :

Code :

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

1
2
3
4
5
6
7
concatMaybeList a b = x ++ y
                     where x = case a of
                                   Just val -> val
                                   Nothing  -> []
                           y = case b of
                                   Just val -> val
                                   Nothing  -> []

merci quand même

[Jedai]

Note que tu peux éviter la répétition :

Code :

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

1
2
3
4
import Data.Maybe (fromMaybe)
 
concatMaybeLists mxs mys = toList mxs ++ toList mys
  where toList = fromMaybe []

Si tu ne distingues pas les cas "Just []" de "Nothing", ton type d'origine n'est probablement pas approprié non plus, peut-être devrais tu le reconsidérer et le remplacer simplement par une liste.

--
Jedaï

[mimi6060]

comment je dois m'y prendre pour distinquer les 2 cas alors ?
comment avoir une liste de [Nothing,Nothing] ou [Just 'a' ,Nothing]

[Jedai]

comment je dois m'y prendre pour distinquer les 2 cas alors ?

Tu ne les distingues pas, justement : ta fonction concatMaybeList traite Just [] ou Nothing exactement de la même façon ce qui est étonnant si les deux cas sont vraiment différents. Le choix est donc :

• soit ta fonction est correcte et tu dois revoir ton choix de structure de donnée, peut être une simple liste plutôt qu'une "Maybe liste" suffirait-elle à tes besoins.
• soit ta fonction est erronée et devrait traiter différemment les cas Nothing et Just []
• ta fonction est un cas spécial et il y a une différence entre Nothing et Just [] avant que tu l'appliques mais après il n'y a plus de distinctions à faire.

comment avoir une liste de [Nothing,Nothing] ou [Just 'a' ,Nothing]

Je ne comprend pas, pour l'instant nous parlions de Maybe [a], pas de [Maybe a] ? Pourrais-tu préciser ta question ?
--
Jedaï

[mimi6060]

peux-t-on faire des liste de maybe?

[Jedai]

peux-t-on faire des liste de maybe?

Bien sûr ! On peut faire des listes de n'importe quel type, or "Maybe a" est un type (si "a" est un type), donc on peut faire des listes de valeurs optionnelles, essaie dans GHCi :

Code :

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

> :t [Just 3, Nothing, Just (-5)]

Par exemple.
Note qu'on peut même faire des listes de fonctions ("a -> b" est un type) même si on ne peut pas les afficher (parce que "a -> b" n'est pas une instance de la typeclass Show) :

Code :

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

> map (\f -> f 5) [(+ 3), subtract 5, (^2)]

--
Jedaï