Float)

Version imprimable

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:

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

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:

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:

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

09/02/2016, 07h58
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:

1 2 3 case operation "+" of Just f -> f 2 2 Nothing -> error "opération inconnue"
ou dans GHCi sur une seule ligne :

Code:

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:

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:

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:

1 2 3 import Data.Maybe (fromJust) ... (fromJust (operation "+")) 2 2
Bonne continuation.
--
Jedaï