Haskell, error unwrapping Maybe Int - haskell

Question

I wrote code:
is3 :: Int -> Maybe Int
is3 x = is3temp 0 x
is3temp :: Int -> Int -> Maybe Int
is3temp p x = if (abs p*p*p) < (abs x) then (is3temp (p+(signum x)) x) else (if p*p*p == x then (Just p) else Nothing)
c :: Maybe Int -> Int
c (Just x) = 2*x+1
c Nothing = 0
--fun::Int -> Int
--fun = c.is3
c1:: Int -> Int
c1 x = 2*x +1
c1 0 = 0
fun::Int -> Int
fun x = (is3 x) >>= c1
As you can see is3 takes Int and returns Maybe Int.
In fun I take result from is3 unwrap it and try to send it to c1.
And get error
ERROR file:1627.hs:47 - Type error in application
*** Expression : is3 x >>= c1
*** Term : c1
*** Type : Int -> Int
*** Does not match : a -> b c
What is wrong here?

Answer 1

Let's inspect all types that come together in is3 x >>= c1:
x :: Int
is3 :: Int -> Maybe Int
c1 :: Int -> Int
||| /???\
is3 x :: Maybe Int ||| ???????
(>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b
(>>=) is3 x :: (Int -> Maybe b) -> Maybe b
is3 x >>= c1 :: $!%&/#?
As you can see, c1 doesn't work as right hand side of >>=, since it's return type is wrong. It must return some kind of Maybe. One can easily fix this with return . c1:
return . c1 :: Int -> Maybe Int
or with fmap, since the monad laws dictate that both must have the same effect:
fmap c1 :: Maybe Int -> Maybe Int
fmap c1 (is3 x) :: Maybe Int
However, this will also change fun's type. That being said, your functions name are rather bad and c1 is probably a typo (if fun's type is correct). It's possible that you actually wanted to use c:
fun :: Int -> Int
fun x = c (is3 x)

Answer 2

Some code that compiles:
is3 :: Int -> Maybe Int
is3 x = is3temp 0 x
is3temp :: Int -> Int -> Maybe Int
is3temp p x = if (abs p*p*p) < (abs x) then (is3temp (p+(signum x)) x) else (if p*p*p == x then (Just p) else Nothing)
c1 :: Int -> Int
c1 0 = 0
c1 x = 2*x +1
fun :: Int -> Maybe Int
fun = (fmap c1) . is3
I changed the type of fun from Int -> Int to Int -> Maybe Int, and am using fmap instead of >>=.
Also I flipped the order of the matches in c1. Matches are applied top to bottom, so the 0 case never would have applied in the order you have it.