Haskell无法将类型`Stack'与`IO'匹配

Question

this is my first time to use Haskell and i have read many many tutorials about it. But when it came to practice, many problems show up. I m trying to make a stack data structure and use it in the Do block. But when i do this. It says cant match type'Stack' with 'IO', i have no idea about this problem. Following is my code:

import Data.Array.IO

main::IO()
main = do
     arr <- newArray((0,0),(8,13)) 0 ::IO (IOArray(Int,Int) Int) 
     list <- getElems arr
     print list
     push 0 mystack   --here is the problem
     return()

data Stack a = Stack [a] deriving Show

empty :: Stack a
empty = Stack []

push :: a -> Stack a -> Stack a 
push x (Stack xs)= Stack (x:xs)

pop :: Stack a -> (Maybe a, Stack a)
pop (Stack []) = (Nothing, Stack [])
pop (Stack (x:xs)) = (Just x, Stack xs)

mystack = empty

Problem is below(when i put push 0 mystack in the Do block it shows up)

Couldn't match type `Stack' with `IO'
    Expected type: IO Integer
      Actual type: Stack Integer
    In the return type of a call of `push'
    In a stmt of a 'do' block: push 0 mystack

Answer 1

The problem here is that main has type IO () , meaning that any statement inside the do block must have type IO a for some type a . Your data type is Stack a , which does not match IO a . You also look like you're wanting some sort of "mutable state" with your stack, but all your functions are pure, meaning they simply return a new value. Values in Haskell are immutable , meaning that they can't be modified after being declared. For most purposes, Haskell doesn't have variables, just named values.

What you probably really want is to use the State monad. You could modify your push and pop functions to work in that monad instead, and then use execState to run the stateful computation:

import Control.Monad.State

data Stack a = Stack [a] deriving (Eq, Show)

push' :: a -> Stack a -> Stack a
push' x (Stack xs) = Stack (x:xs)

push :: a -> State (Stack a) ()
push x = modify (push' x)

pop' :: Stack a -> (Maybe a, Stack a)
pop' (Stack []) = (Nothing, Stack [])
pop' (Stack (x:xs)) = (Just x, Stack xs)

pop :: State (Stack a) (Maybe a)
pop = state pop'

Notice how easy it was to directly use your already written functions to implement this! You even had pop return the Maybe a in the first element of the tuple to go straight into the state function. You can then use this as

main :: IO ()
main = do
    let resultStack = flip execState empty $ do
            push 1
            push 2
            push 3
            pop                    -- pop off 3
            Just x <- pop          -- pop off 2
            push $ 2 * x           -- push 4
            mapM_ push [1..10]     -- Pushes 1 through 10 onto the stack in that order
            pop                    -- pop off 10
            pop                    -- pop off 9
            pop                    -- pop off 8
    print resultStack

This will print out

Stack [7, 6, 5, 4, 3, 2, 1, 4, 1]

Answer 2

push 0 mystack returns a new stack. You are not getting the return value, and you are writing this line as an "action". "Actions" are things that change the global state of the system, they are marked by functions returning IO. Since push doesn't change the global state, haskell tells you that there's no reason to call it like you do.

What you probably mean is:

let newStack = push 0 mystack

Answer 3

Inside a do block, consecutive lines like:

do
  print list
  print "something else"

get translated to:

print list >> print "something else"

where >> has type IO a -> IO b -> IO b when using IO as you are here.

So for:

print list
push 0 mystack

to compile, push 0 mystack must return an IO a for some type a , however push 0 mystack returns a Stack Integer , hence the error.

If you want to bind a regular value inside a do block you can use let eg

let stack' = push 0 mystack

Answer 4

Other answers have already proposed a few solutions. Here, let me comment about what your code actually means. Let us focus on your main :

main = do
     arr <- newArray((0,0),(8,13)) 0 ::IO (IOArray(Int,Int) Int) 
     list <- getElems arr
     print list
     push 0 mystack   --here is the problem
     return()

As the error points out, the problem lies in the push 0 mystack line. Now, Haskell is a pure language in which every defined value (such as push , or mystack ) can be replaced by its own definition without affecting the program meaning. This feature is often called "referential transparency". We can then state that the line

push 0 mystack

is equivalent to (by definition of mystack )

push 0 empty

which is equivalent to (by definition of empty )

push 0 (Stack [])

which is equivalent to (by definition of push )

Stack (0:[])

which can be written using the more common syntax as

Stack [0]

Hence, your main actually means

main = do
     arr <- newArray((0,0),(8,13)) 0 ::IO (IOArray(Int,Int) Int) 
     list <- getElems arr
     print list
     Stack [0]   --here is the problem
     return()

Now it is easy to see that the problematic line is indeed such. It mentions a Stack value, but it does not specify what to do on that. We could, for instance, just print it using

print (Stack [0])  -- or, equivalently, print (push 0 mystack)

or we could define a variable with such value

let s = Stack [0]   -- or, equivalently, let s = push 0 mystack
...
print s

In general we could do anything with such a value.

---

In the case you were trying to "modify" the value of mystack , know that you can not in a pure language as Haskell. Indeed, to modify the value of mystack is as meaningful as modifying the value of Stack [] , by referential transparency. Haskell variables denote values rather than mutable memory cells. Perhaps surprisingly at first, one can often program without mutable variables. This might feel impossible, or impractical, when one has been programming in an imperative language since a long time, but once accustomed with pure functional programming this feels very natural, and pays back in many ways (eg allowing equational reasoning about code, much fewer concerns on concurrent programming, etc.). When you really need mutable state, you can use the State monad, or the IO moand and IORef s, or ST and STRef , for instance. These however should be used when the stateful approach is really the best, simplest approach to express your algorithm. In practice, this is rarely so, and even when it is, often one can still write most of the subroutines without having side effects on the state.