Error in the haskell program - haskell

Question

I have made the following haskell program which will do some basic operations of load, read and increment. I am getting a type error. Can someone please tell why type error is there and how can i resolve it.
module ExampleProblem (Value,read',load,incr) where
newtype Value a = Value Int deriving (Eq,Read,Show)
read':: Value Int -> Int
read' (Value a) = a
load:: Int -> Value Int
load a = Value a
incr:: Value Int -> Value Int
incr (Value a) = Value (a+1)
main = do
(Value ab) <- (load 42)
if (read'( Value ab) /= 42)
then show "Failure to load"
else do
Value b <- incr( Value ab)
Value c <- incr( Value b)
if ((Value c) == Value 44)
then show "Example finished"
else show "error"
return
The error i get is:
Couldn't match expected type `Int' with actual type `Value t0'
In the pattern: Value ab
In a stmt of a 'do' expression: (Value ab) <- (load 42)
In the expression:
do { (Value ab) <- (load 42);
if (read' (Value ab) /= 42) then
show "Failure to load"
else
do { Value b <- incr (Value ab);
.... } }
And when i made a separate file in which i had written the main function i was getting the error of scope although i was importing the module ExampleProblem.
Not in scope: data constructor `Value'

Answer 1

It seems you are confused about how to use do-notation. Do-notation is used for composing actions in a monad. In the case of main, that monad will be IO so I'll be sticking with IO to keep things simple.
There are three types of statements you can use in do-notation:
x <- foo binds the result of running the action foo to the pattern x. foo must have type IO Something, and x will then have the corresponding type Something.
let x = foo binds a value without anything special happening. This is the same as = at the top level, except that any preceding bindings are in scope.
foo runs an action of type IO Something. If it's the last statement in the do-block, this becomes the result of the block, otherwise the result is ignored.
The main problem in your code is that you're using x <- foo statements with things that aren't IO actions. That won't work. Instead, use the let x = foo form.
Secondly, show is also not an IO action. It's just a function that converts stuff to String. You probably meant to use putStrLn which will print a string to standard output.
Thirdly, return is not a statement like in C or Java. It's a function which, given a value, produces an action that does nothing and returns the value. It is often used as the last thing in a do-block when you want it to return a pure value. Here it is unnecessary.
And finally, if you want to run this code, your module must be called Main and it must export the main function. The easiest way of doing this is just to remove the module ... where line and the name will default to Main. You typically only want this line with the in modules in your project which don't contain main.
main = do
let Value ab = load 42
if read' (Value ab) /= 42
then putStrLn "Failure to load"
else do
let Value b = incr (Value ab)
let Value c = incr (Value b)
if Value c == Value 44
then putStrLn "Example finished"
else putStrLn "error"
This should work, but you're needlessly wrapping and unwrapping your values in the Value type. Perhaps you intended something like this:
main = do
let ab = load 42
if read' ab /= 42
then putStrLn "Failure to load"
else do
let b = incr ab
let c = incr b
if c == Value 44
then putStrLn "Example finished"
else putStrLn "error"

Answer 2

I'll start with your second question.
newtype Value a = Value Int deriving (Eq,Read,Show)
This actually creates two Values:
the Value in newtype Value a is a type constructor
the Value in Value Int is a data constructor (usually just call it a constructor)
They are different things!
module ExampleProblem (Value,read',load,incr) where
Here Value means the type constructor. To export the data constructor as well, you need
module ExampleProblem (Value(Value),read',load,incr) where
Now, about your first question.
main must have type IO something
You've set main to be a do block, so that means
everything to the right of an <- must have type IO somethingOrOther
The line with the error message is
(Value ab) <- (load 42)
load 42 has type Value Int, clearly nothing to do with IO, so you get an error.
So how do you fix this?
if a line of code in a do block is not an IO statement, it must be a let statement1
Other errors you need to fix:
return doesn't do what it does in every other language.
In particular, it always takes a value to return.
We should have called it something else. Sorry about that.
Imagine it's called pure instead. Anyway, you don't need it here.
to print a String to the screen, you should use putStrLn, not show.
Ghci prints the return value of expressions you give it, but this is a program in its own right,
so you have to do the IO yourself.
then and else need to be indented further than the if (I think this rule is changing, but I don't think it has yet)
So we end up with
main = do
let Value ab = load 42
if read' (Value ab) /= 42
then putStrLn "Failure to load"
else do
let Value b = incr (Value ab)
let Value c = incr (Value b)
if Value c == Value 44
then putStrLn "Example finished"
else putStrLn "error"
Footnotes:
Not strictly true: do blocks can be used for things other than IO. But you'll learn about that later.

Answer 3

One additional remark: You should try to do as much work outside the main-IO thing as possible. In your case it's easy: You have a calculation which takes no argument and produces a String (which should be printed out). If you had different "outcomes", you could use e.g. Either, but here we are fine with just String as return type.
As hammar pointed out it makes not much sense to pattern match and reconstruct Value all the way, just use the values as they are, and use pattern matching only if you need to access the number inside.
The type Value doesn't need to be polymorphic if it always wraps just an Int, so I dropped the a. Else you have something called a "phantom type", which is possible and sometimes even useful, but definitely not here (of course if you want to be able to wrap arbitrary types, you can write data Value a = Value a).
So here is a version which does only the bare minimum in IO, and keeps everything else pure (and hence flexible, testable etc):
data Value = Value Int deriving (Eq,Read,Show)
read':: Value -> Int
read' (Value a) = a
load:: Int -> Value
load a = Value a
incr:: Value -> Value
incr (Value a) = Value (a+1)
main = putStrLn calc
calc :: String
calc = let ab = load 42
in if read' ab /= 42 then "Failure to load" else increaseTwice ab
increaseTwice :: Value -> String
increaseTwice v = let b = incr v
c = incr b
in if c == Value 44 then "Example finished" else "error"
I can't use Haskell here, so I hope this works...