Discussion :

[oduhart]

Bonjour,

Je démarre tout justeavec Haskell. Je développe quelques petits programmes pour me faire la main. J'ai fait un evaluateur de notation polonaise inversée qui fonctionne bien mais j'aimerais l'améliorer avec l'utilisation de Maybe notamment. Et c'est là que je butte.

Je voudrais avoir une fonction qui me retourne une fonction Float-> Float->Float à partir d'un nom de fonction ( (+) pour "+" par exemple)
et rien (Nothing) si la fonction n'est pas connue.

Mon implémentation actuelle est la suivante

Code :

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

1
2
3
4
5
6
7
operation :: String -> Maybe Float -> Float -> Float
operation op 
   | op == "+" = Just (+)
   | op == "-" = Just (-)
   | op == "*" = Just (*)
   | op == "/" = Just (/)
   | otherwise = Nothing

Mais la compilation échoue :

rpn.hs:64:18:
Couldn't match expected type `Maybe Float -> Float -> Float'
with actual type `Maybe a0'
In the expression: Nothing
In an equation for `operation':
operation op
| op == "+" = Just (+)
| op == "-" = Just (-)
| op == "*" = Just (*)
| op == "/" = Just (/)
| otherwise = Nothing


je ne comprends pas ce que je loupe. Dois je typer explictement le Nothing ? si oui comment ?
Ou alors n'ai je pas bien compris le Maybe ?

Merci d'avance pour votre aide


Olivier

[oduhart]

J'ai trouvé comment réussir une compilation de ma fonction :

operation :: String -> Maybe (Float -> Float -> Float)
operation op
| op == "+" = Just (+)
| op == "-" = Just (-)
| op == "*" = Just (*)
| op == "/" = Just (/)
| otherwise = Nothing

Le paranthésage semble résoudre l'erreur de compilation.
mais maintenant j'échoue à l'execution avec l'erreur suivante :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
*Main> (operation "+") 2.0 2.0
 
<interactive>:3:1:
    Couldn't match expected type `Double -> Double -> t'
                with actual type `Maybe (Float -> Float -> Float)'
    Relevant bindings include it :: t (bound at <interactive>:3:1)
    The function `operation' is applied to three arguments,
    but its type `String -> Maybe (Float -> Float -> Float)'
    has only one
    In the expression: (operation "+") 2.0 2.0
    In an equation for `it': it = (operation "+") 2.0 2.0

ou encore ::

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
*Main> (Just (operation "+")) 2.0 2.0
 
<interactive>:3:1:
    Couldn't match expected type `Double -> Double -> t'
                with actual type `Maybe (Maybe (Float -> Float -> Float))'
    Relevant bindings include it :: t (bound at <interactive>:3:1)
    The function `Just' is applied to three arguments,
    but its type `Maybe (Float -> Float -> Float)
                  -> Maybe (Maybe (Float -> Float -> Float))'
    has only one
    In the expression: (Just (operation "+")) 2.0 2.0
    In an equation for `it': it = (Just (operation "+")) 2.0 2.0

[Jedai]

Comme tu l'as compris, ta première signature était équivalente à "String -> (Maybe Float) -> Float -> Float" car l'application (ici de Maybe) est toujours prioritaire (ici par rapport à l'opérateur ->).

Maintenant ton problème est que tu essaies d'appliquer (operation "+") comme si c'était une fonction mais c'est un Maybe qui contient (éventuellement) une fonction...

Pour l'appliquer, il y a plusieurs possibilités :

Extraire la fonction dans un pattern match :

Code :

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

1
2
3
case operation "+" of
  Just f -> f 2 2
  Nothing -> error "opération inconnue"

ou dans GHCi sur une seule ligne :

Code :

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

case operation "+" of {Just f -> f 2 2; Nothing -> error "opération inconnue"}

Tu peux également utiliser le fait que Maybe est un Functor pour traiter les deux cas de façon transparente :

Code :

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

fmap (\f -> f 2 2) (operation "+")

Attention toutefois, cette fois ci le résultat sera du type "Maybe Float" (Just résultat ou Nothing si l'opération est inconnue).

Ceci peut également s'écrire de la façon suivante avec la monade Maybe :

Code :

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

1
2
3
do
  f <- operation "+"
  return (f 2 2)

La façon dont tu procèdes dépendra de tes besoins (la monade est par exemple parfaite si tu as d'autres source de Maybe, par exemple pour les opérandes, et que tu veux les combiner en obtenant Nothing dès que l'un d'entre eux échoue).

Dernière façon de faire, ici appropriée parce que tu sais que l'opération existe (mais alors pourquoi ne pas utiliser directement (+) ...) mais à éviter en général :

Code :

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

1
2
3
import Data.Maybe (fromJust)
 
... (fromJust (operation "+")) 2 2

Bonne continuation.
--
Jedaï