Haskell错误； 进行检查：无法构造无限类型：t〜[t]

Question

I asked a few questions yesterday and more and more problems kept creeping up in my code.

I have a function called sub. Sub takes in a number and outputs a list of numbers, the code is below.

sub 5 =  [1]
sub x =
    do 
        xs <- sub (x - 1)
        (x:xs)  

I used to have to where on the top line had sub 5 = return [1] and on the bottom line, return (x:xs). Someone answered yesterday and told me to take these out as it's putting a list within a list, like so [[int]]. If I take out the returns this generates an error (In the question title), I really can't get my head around this.

Just wondering if anyone can make sense of it,

Thanks

Answer 1

I'll try to expand what the error means.

Lets desugar do notation ( details ):

sub 5 =  [1]
sub x =
        sub (x - 1) >>= \xs ->
        (x:xs)  

The >>= operator has the next type (see here ):

(>>=) :: Monad m => m a -> (a -> m b) -> m b

The first its argument, sub (x - 1) , has type [Int] , so we can instantiate type variables m to [] and a to Int :

(>>=) :: [Int] -> (Int -> [b]) -> [b]

(Note that [a] is a special syntax for list type, you can read it as [] a )

So the second argument, \\xs -> (x:xs) , should have type Int -> [b] . It should be clear now that xs has type Int , not [Int] as you seems to expect.

Now lets consider : . Its type is c -> [c] -> [c] . Let write down all constrains:

(:)     :: c -> [c] -> [c]
x       :: Int
xs      :: Int
x : xs  :: [Int]

They can't be satisfied at the same time because they require c and [c] both to be Int .

Answer 2

Let's rewrite what you have to make clearer why this won't typecheck. We first desugar the do notation to get

sub :: Int -> [Int]
sub 5 = [1]
sub x = sub (x-1) >>= \xs -> (x:xs)

Now recall how >>= is defined for lists: ys >>= f = concat (map f ys) . Here f is \\xs -> (x:xs) and ys is sub (x-1) , so therefore we have:

sub :: Int -> [Int]
sub 5 = [1]
sub x = concat (map (\xs -> (x:xs)) (sub (x-1)))

The type of sub (x-1) is [Int] , so the first argument to map must be a function that takes an Int . It is not - it expects a list!

As you say, you used to have sub 5 = return [1] . Recall that for lists return y = [y] , so in that case your sub would have signature Int -> [[Int]] . Now sub (x-1) in the above would be a list of lists, and the first argument to map should be a function that takes lists , which is indeed the case. So things typechecked.

A piece of advice: Give your top-level definitions explicit signatures (is it sub :: Int -> [Int] or sub :: Int -> [[Int]] that you want?)! It'll make it easier to understand what's going on because it forces you to think about what you actually want.