Haskell递归函数“无法构造无限类型”

Question

I'm trying to build a recursive function that will help me solve Project Euler problem 15 in Haskell (I'm very new to it), but the compiler tells me:

 Occurs check: cannot construct the infinite type: t ~ [t]
 Relevant bindings include
   grid :: t (bound at 15.hs:1:22)
   r :: t (bound at 15.hs:1:17)
   d :: t (bound at 15.hs:1:15)
   generateTree :: [t] -> t -> [t] (bound at 15.hs:1:1)
 In the expression: generateTree [d + 1, r] grid
 In the expression:
   [generateTree [d + 1, r] grid, generateTree [d, r + 1] grid]

I'm not really too sure whats the problems, and I've come across compilers complaining at me in an easier way to understand. Here is my function:

generateTree (d:r:_) grid
    | down && right = [generateTree [d + 1, r] grid, generateTree [d, r + 1] grid]
    | down = [generateTree [d + 1, r] grid, -1]
    | right = [-1, generateTree [d, r + 1] grid]
    | otherwise = [d, r]
    where down = elem d [0..grid]
          right = elem r [0..grid]

Thanks

Answer 1

The reason why you're seeing the error is that you're trying to say that generateTree returns values like [-1, [-1, [-1, 0]]] , which doesn't have a valid type in Haskell. All values in a list have to have the same type, which means that lists can't be nested like this. You could nest it like [[[-1]], [[-1], [-1, 0]]] , but this would have the type [[[Int]]] , meaning it could only ever be 3 levels deep. You want arbitrarily nested levels, so you'll need a new data type that defines such a recursive structure.

Since your function only ever is returning two elements in a list, you could do this with a binary tree. Luckily, this is pretty simple in Haskell:

data Tree a = Leaf a | Node (Tree a) (Tree a) deriving (Eq, Show)

Here Leaf a represents a single value, and Node left right represents a split in the tree, so you could have

Node
    (Leaf (-1))
    (Node
        (Leaf (-1))
        (Node
            (Leaf (-1))
            (Leaf 0)
        )
    )

^{(whitespace added for clarity)}

Which would be equivalent to the invalid list above of [-1, [-1, [-1, 0]]] . Is this more verbose? Of course, but it allows arbitrary nesting.

Now you just have to modify your function definition to use this type:

generateTree :: Int -> Int -> Int -> Tree Int
generateTree d r grid
    | down && right = ...
    | down          = ...
    | right         = Node (Leaf (-1)) (generateTree d (r + 1) grid)
    | otherwise     = Node (Leaf d) (Leaf r)
    where
        down = d `elem` [0..grid]
        right = r `elem` [0..grid]

I'll let you finish the rest of the definition, this is just an example to get you started.

Answer 2

Your generateTree function returns a list, see:

| otherwise = [d, r]

But What is the type of d and r ? generateTree returns a list of whatever the generateTree function returns (all elements in a list must be the same type):

| right = [-1, generateTree [d, r + 1] grid]

In other words, your logic is broken. Learn the type system, learn to write the types and then the error will become apparent.