Haskell – couldn’t match expected type

haskell

I would like to do something different but it would be too long so below is only example:

test x y = if x == "5" then x
           else do putStrLn "bad value"; y

so if x == 5 it should return x, else it should print 'bad value' and return y – how can I do that in haskell ?

edit:

Why this code returns error: "couldn't match expected type bool with actual type IO bool" ?

canTest :: String -> IO Bool
canTest x = if x == "5" then return True
           else do putStrLn "bad value"; return False

test x y = if canTest x then x
           else y

Best Answer

You need to make both sides have the same type, namely IO String. For this you need to use return to lift the values into the monad, i.e.

test :: String -> String -> IO String
test x y = if x == "5"
             then return x
             else do putStrLn "bad value"
                     return y

Now return x has the type IO String, and so does the do block in the else branch.

Related Solutions

Haskell – Error trying to call putStrLn in function

It is important to remember that Haskell is a pure functional language. This means that functions are not allowed to have any side effects at all, including printing debug messages to your screen.

It is however possible to break this purity and it can be useful in debugging. Take a look at the module Debug.Trace. There you will find a function trace :: String -> a -> a. You can use it in your code like this:

import Debug.Trace

isAFactor :: Integer -> Integer -> Bool 
isAFactor x y = x `mod` y == 0

findFactors :: Integer -> Integer -> [Integer]
findFactors counter num = 
    let quotient = div num 2
    in
        if(counter >  quotient)
                then trace ("factorList is: " ++ show quotient) [] 
        else if(isAFactor num counter)
            then [counter] ++ [quotient] ++ findFactors (counter + 1) num
        else
            findFactors (counter + 1) num

As the comments suggested:

Haskell is also a lazy language. An Expression is not evaluated before the result is actually needed. Using the trace function can be a bit confusing in a lazy setting because it is not always easy to understand when the trace message is printed to screen (if it is printed at all).

As haskell is a very different kind of language it is perhaps best to try and develop programs in a equally different way. Try to reason about your functions instead of using trace and similar "unpure" constructs. Learn to take advantage of haskells powerful type system and use (for example) QuickCheck to test your function once it passed the type checker.

Haskell: Couldn’t match type ‘Char’ with ‘[Char]’

The problem is in your definition of removeT. The type of removeT is [String] -> [String], meaning it works on a list of lists of characters. Then, in your filter, you compare each list of characters (i.e., each String in the list) to a Char ('t'). This is not allowed (you cannot check values with different types for equality).

How to change your code really depends on what you intend to do. It's not entirely clear if you want to remove lines containing t's, if you want to keep lines containing t's, if you want to remove t's, or if you want to keep t's. Depending on what you want to achieve, your code will have to be modified accordingly.

Some pointers:

If you change the type of removeT to String -> String you can look at one line at a time. You would then have to replace removeT in the definition of createIndex by map removeT (because you're applying the function to each line)). In this case, the filter would deal with Char values so comparing with a 't' is allowed.
If you want to do something with lines containing t's, (== 't') is not the way to go, you will want to use ('t' `elem`) (meaning "'t' is an element of").
filter keeps elements matching the predicate. So if you want to remove t's from a string for example, you use filter (/= 't').

Best Answer

Related Solutions

Haskell – Error trying to call putStrLn in function

Haskell: Couldn’t match type ‘Char’ with ‘[Char]’

Related Topic