List Haskell代码中的嵌套列表理解错误

我试着用Haskell写下下面的列表，它不会进行打字检查。我是新手，不知道为什么

something :: Int -> [Int]
something n = [[ 2 * x + 1 | x <- xs]|xs <- [3..n],i <- [1..],j <-[1..] ,xs == i+j+2*i*j,i<=j,i>=1]

something:：Int->[Int]
n=[[2*x+1 | x首先，函数名不能是大写

xs首先，函数名不能是大写

xs首先，您有一个嵌套的列表理解，因此您正在创建一个列表列表，因此返回类型应该是
[[Int]]
（Int列表）而不是
[Int]
（Int列表）

其次，
xs
是一个数字（因为你从数字列表中取出来），但它的名字表明它是一个列表，当你做
x时，首先你有一个嵌套的列表理解，所以你要创建一个列表列表，所以返回类型应该是
[[Int]
（Int列表）而不是
[Int]
（INT列表）

其次，
xs
是一个数字（因为你把它从数字列表中取出来），但它的名字表明它是一个列表，当你做
x时，让我们从你得到的开始

something n = [[ 2 * x + 1 | x <- xs]|xs <- [3..n],i <- [1..],j <-[1..] ,xs == i+j+2*i*j,i<=j,i>=1]

类似地，我们可以摆脱
i让我们从您拥有的开始

something n = [[ 2 * x + 1 | x <- xs]|xs <- [3..n],i <- [1..],j <-[1..] ,xs == i+j+2*i*j,i<=j,i>=1]

类似地，我们可以摆脱我怀疑的
iAs，我在不止一个方面搞砸了。我确实最终想要[Int]。所以我想我需要做一些超出理解的事情。我也看到了xs作为一个数字的问题。请参见编辑。正如我怀疑的，我在不止一个方面搞砸了。我确实想要[Int]最后，我想我需要做一些超出理解范围的事情。我也看到了xs作为一个数字的问题。请参见编辑。
[ 2 * x + 1 | x <- [3..n], i <- [1..x],j <-[1..x], x == i+j+2*i*j, i<=j]

[ 2 * x + 1 | x <- [3..n], i <- [1..x], j <-[i..x], x == i+j+2*i*j]

something n = [[ 2 * x + 1 | x <- xs]|xs <- [3..n],i <- [1..],j <-[1..] ,xs == i+j+2*i*j,i<=j,i>=1]

something n = [ 2 * x + 1 | x <- [3..n], i <- [1..], j <- [1..], x == i+j+2*i*j, i<=j, i>=1]

something n = [ 2 * x + 1 | x <- [3..n], i <- [1..], j <- [1..], x == i+j+2*i*j, i<=j]

something n = [ 2 * x + 1 | x <- [3..n], i <- [1..], j <- [i..], x == i+j+2*i*j]

something n = [ 2 * x + 1 | x <- [3..n], i <- [1..], j <- [i .. (n - i) `div` (1 + 2 * i)], x == i+j+2*i*j]

something n = [ 2 * x + 1 | x <- [3..n], i <- [1 .. (n `div` 3) - 1], j <- [i .. (n - i) `div` (1 + 2 * i)],
                            x == i+j+2*i*j]

something n = nub [ 2 * x + 1 | x <- [3..n], i <- [1 .. (n `div` 3) - 1],
                                j <- [i .. (n - i) `div` (1 + 2 * i)], x == i+j+2*i*j]

something n = nub [ 2 * x + 1 | i <- [1 .. (n `div` 3) - 1], j <- [1 .. (n - i) `div` (1 + 2 * i)],
                                let x = i+j+2*i*j]

something n = sort $ nub [ 2 * x + 1 | i <- [1 .. (n `div` 3) - 1], j <- [1 .. (n - i) `div` (1 + 2 * i)],
                                       let x = i+j+2*i*j]

something n = sort $ map f $ nub [ x | i <- [1 .. (n `div` 3) - 1], j <- [1 .. (n - i) `div` (1 + 2 * i)],
                                   let x = i+j+2*i*j]
  where f x = 2 * x + 1

something n = sort $ map f $ nub [ i+j+2*i*j | i <- [1 .. (n `div` 3) - 1],
                                               j <- [1 .. (n - i) `div` (1 + 2 * i)]]
  where f x = 2 * x + 1