1

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'
Improve this question
2
  • 5 questions and no answers accepted. Work on that please. Commented Jan 24, 2012 at 8:26
  • 1
    Sorry i did not know about it.. Have made amends now :) Commented Jan 24, 2012 at 8:33

3 Answers 3

Reset to default
5

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:

  1. 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.

  2. 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.

  3. 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"
Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

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:

  1. Not strictly true: do blocks can be used for things other than IO. But you'll learn about that later.
Improve this answer

Comments

2

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...

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.