预期类型[Int]-实际类型[[Int]]-Haskell递归

我正在处理Haskell中的一个函数，该函数接收一个包含矩形宽度和高度的字符串（该字符串的格式类似于“宽度-长度”或“13”）。然后它递归地计算出将填充该矩形的正方形的边长，并返回填充该矩形的每个正方形的所有边长（它将只返回每个正方形的一个边长，因为正方形只有一个唯一的边长）

我遇到的问题是，每当我运行下面的代码时，Haskell都会告诉我，当需要[Int]类型时，我试图返回类型[[Int]]。我是Haskell的新手，在将Int放入集合并返回之前，我很难弄清楚到底是什么导致我的Int变成了[Int]

module MakeSquares where

import Data.List

solve :: String -> [Int]

solve s
 |lengthOne == lengthTwo = return [lengthOne]
--If we run into any problems then add a where statement definining the equation in "show"
 |lengthOne > lengthTwo = do f <- solve (intercalate " " [show lengthOneMinusTwo, show lengthTwo])
                             return (lengthTwo:f)
 |lengthOne < lengthTwo = do f <- solve (intercalate " " [show lengthTwoMinusOne, show lengthOne])
                             return (lengthOne:f)
 where
  input = words s
  stringLengthOne = input!!0
  stringLengthTwo = input!!1
  lengthOne = read stringLengthOne::Int
  lengthTwo = read stringLengthTwo::Int
  lengthOneMinusTwo = lengthOne - lengthTwo
  lengthTwoMinusOne = lengthTwo - lengthOne

模块生成方块，其中
导入数据。列表
solve:：String->[Int]
解s
|lengthOne==lengthOne=返回[lengthOne]
--如果遇到任何问题，请添加where语句，在“show”中定义方程式
|lengthOne>lengthTwo=do f
return
不是，因为在过程语言中，这是函数的结果<代码>返回

在一元上下文中包装项目。由于这里函数的返回类型是

[Int]

，

返回

使用

Monad

的

[]

实例，因此

返回

将该项包装在单例列表中

你应使用：

solve :: String -> [Int]
solve s
 | lengthOne == lengthTwo = [lengthOne]  -- ← no return
 | lengthOne > lengthTwo = do
    f <- solve (intercalate " " [show lengthOneMinusTwo, show lengthTwo])
    (lengthTwo:f)  -- ← no return
 |lengthOne < lengthTwo = do
    f <- solve (intercalate " " [show lengthTwoMinusOne, show lengthOne])
    (lengthOne:f)  -- ← no return

---

问题在于

do

块。在正确理解单子之前，不要将

do

或

return

用于除

IO

排序以外的任何内容

你想写的是

 |lengthOne == lengthTwo = [lengthOne]
 |lengthOne > lengthTwo = let f = solve (intercalate " " [ show lengthOneMinusTwo
                                                         , show lengthTwo ])
                          in (lengthTwo:f)
 |lengthOne < lengthTwo = let f = solve (intercalate " " [ show lengthTwoMinusOne
                                                         , show lengthOne ])
                          in (lengthOne:f)

---

然后你可以扔掉所有的

单词

，

阅读

，

显示

和

插入

积垢。

你真的不应该使用

或字符串作为输入。在haskell中，您应该使用数据类型来表示复杂的数据结构
solve s
 | lengthOne == lengthTwo = [lengthOne]
 | lengthOne > lengthTwo =
    --            ↓ subexpression
    (lengthTwo: solve (intercalate " " [show lengthOneMinusTwo, show lengthTwo]))  
 |lengthOne < lengthTwo =
    --            ↓ subexpression
    (lengthOne:solve (intercalate " " [show lengthTwoMinusOne, show lengthOne]))
 |lengthOne == lengthTwo = [lengthOne]
 |lengthOne > lengthTwo = let f = solve (intercalate " " [ show lengthOneMinusTwo
                                                         , show lengthTwo ])
                          in (lengthTwo:f)
 |lengthOne < lengthTwo = let f = solve (intercalate " " [ show lengthTwoMinusOne
                                                         , show lengthOne ])
                          in (lengthOne:f)

 | lengthOne == lengthTwo = [lengthOne]
 | lengthOne > lengthTwo
 , f <- solve (intercalate " " [show lengthOneMinusTwo, show lengthTwo])
         = lengthTwo:f
 | lengthOne < lengthTwo
 , f <- solve (intercalate " " [show lengthTwoMinusOne, show lengthOne])
         = lengthOne:f

solve :: Int -> Int -> [Int]