[Haskell-beginners] Returning Maybe Float -> Float -> Float

[Olivier Duhart]

thanks Ulrik,

it solves the compilation problem. But now  I have an execution error (with
GHCi) :

*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

As I understand it ghci guess that the two 2.0 parameters to my (operation
"+") are Double and the function returned by operation expects Float
instead, How to solve this ?

I tried to replace every  Float with Double in my .hs file but still there
is a problem

*Main> (operation "+") 2.0 2.0

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

Could you explain me what is the -> t at the end of the expected type ?



Le lun. 8 févr. 2016 à 15:07, Ulrik Rasmussen <haskell at utr.dk> a écrit :

> On 2016-02-08 14:54, Olivier Duhart wrote:
> > hello,
> >
> > I am starting with Haskell and trying some little exercices on my own. I
> > successfully implemented a reverse polish notation evaluator and I want
> > to improve it a little using *Maybe*
> > *
> > *
> > All i want is to implement  a function that can returned available
> > functions according to its string name
> > i.e return (+) when gived "+"
> > I also want to return Nothing if the operation is not available (not
> > implemented yet).
> > So my function should Maybe return a (float -> float -> float)
> >
> > My current implementation is
> >
> >     operation :: String -> Maybe Float -> Float -> Float
> >     operation op
> >         | op == "+" = Just (+)
> >         | op == "-" = Just (-)
> >         | op == "*" = Just (*)
> >         | op == "/" = Just (/)
> >         | otherwise = Nothing
> >
> >
> > but it failed to compile with the following error :
> >
> > 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
> >
> >
> > I don't understand the error :( Do I have to explicitly type the Nothing
> > return ?
> >
> > Could you guide me to a solution or explain me what I am doing wrong,
> > please ?
> >
> > Thanks in advance
> >
> > Olivier
>
> Hi,
>
> The type String -> Maybe Float -> Float -> Float parenthesizes as
>
>     String -> (Maybe Float) -> Float -> Float,
>
> but I think you meant
>
>     String -> Maybe (Float -> Float -> Float)
>
>
> /Ulrik
> _______________________________________________
> Beginners mailing list
> Beginners at haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/beginners/attachments/20160208/65e09e62/attachment.html>