递归函数中的类型匹配和 IO 问题

Question

我遇到了一些问题，但找不到原因。我目前正在使用最新版本的 GHCi 便携版 - 但要面对事实：这是我第一次使用 Haskell，所以像往常一样，问题可能是用户而不是系统...

出现的问题包括：

• 我不完全确定我是否理解了let x = 0 和x <- 0 之间的区别。我知道let 是与纯函数一起使用的，<- 与副作用（IO）一起使用？请有人再次向我解释一下。
• 我的类型不匹配，即String 和(String,[Char])（有时还有其他......）。编译器告诉我 String 是预期的，尽管我明确地将函数定义为 (String,String)。这是怎么回事？我是不是在某个地方对模式匹配有误？
• 递归没有按预期工作（即，显然根本没有工作）。如果有人可以帮助我，我将不胜感激。

---

这是我想做的：
我正在尝试编写一个小程序来实现一个接受单词的有限状态机。这意味着它需要一组状态，其中一个是开始状态、一个接受状态列表和一些转换规则。 （表示可能的输入和状态的字母表有些隐含。）我不想在这里详细介绍 FSM。

但是，这就是我想出一种定义此类 FSM 的方法的方式：

"a(b+|c+)"
"start"
["b","c"]
[
("start",   [('a',"a"),                         ('_',"reject")]),
("a",       [           ('b',"b"),  ('c',"c"),  ('_',"reject")]),
("b",       [           ('b',"b"),              ('_',"reject")]),
("c",       [                       ('c',"c"),  ('_',"reject")]),
("reject",  [                                   ('_',"reject")])
]

在第一行，我们简要描述了 FSM 应该接受的内容（在本例中以正则表达式的形式）。它仅用于显示一次。
第二行定义开始状态，第三行是接受状态列表。
以下所有行一起是转换规则。在这个例子中，如果我们处于“开始”状态并读取输入“a”，则下一个状态是“a”，如果我们读取其他任何内容，则为“拒绝”。 （我知道我还没有实现 '_' 表示 else，如果读取的输入没有定义转换，程序将崩溃。）

所以程序来了：

module FSM where

import System.IO

main :: IO ()
main = do
    putStr "Enter file name: "
    fileName <- getLine
    (description, startState, acceptingStates, stateTransitions) <- (readDef fileName)
    putStrLn ("FSM description: " ++ description)
    putStr "Enter FSM input: "
    input <- getLine
    let input = reverse input
    putStrLn "----------------"
    let (finalState, oldStates) = changeState input startState stateTransitions
    putStrLn (oldStates ++ finalState)
    checkAcception finalState acceptingStates

--reads the specified .fsm file and returns
--  the description of the FSM (first line),
--  the start state (second line),
--  the list of accepting states (third line),
--  and the list of tuples containing all states and transitions (remaining lines)
readDef :: String -> IO (String, String, [String], [(String, [(Char,String)])])
readDef fileName = do
    contents <- readFile (fileName ++ ".fsm")
    let lineList = lines contents
    let description = read (head lineList)
    let startState = read (lineList !! 1)
    let acceptingStates = read (lineList !! 2)
    let stateTransitions = read (filter (/='\t') (concat (drop 3 lineList)))
    return (description, startState, acceptingStates, stateTransitions)

--recursive function that takes the input, start state, and state transitions
--and computes the new state by a call to itself with the old state and a part of the input
changeState :: String -> String -> [(String, [(Char,String)])] -> (String, String)

changeState startState [] _ = (startState, "")

changeState startState (x:xs) stateTransitions = do
    let (currentState, oldStates) = changeState xs startState stateTransitions
    let newState = findKey x (findKey currentState stateTransitions)
    let oldStates = (oldStates ++ currentState ++ " -(" ++ [x] ++ ")-> ")
    return (newState, oldStates)

--helper function to find a key in a list of tuples and return the corresponding value
--(because we are not using the map notation in the .fsm file)
findKey :: (Eq k) => k -> [(k,v)] -> v
findKey key xs = snd . head . filter (\(k,v) -> key == k) $ xs

--checks for a given state whether or not it is in the list of accepting states
checkAcception :: String -> [String] -> IO ()
checkAcception finalState acceptingStates = do
    let accept = any (==finalState) acceptingStates
    if accept
        then putStrLn "Input accepted!!"
        else putStrLn "Input rejected!!"

这个想法是让用户选择一个从中加载定义的文件（readDef，就像一个魅力）。然后提示他输入 FSM 处理的一些输入。
递归的 changeState 然后执行实际工作（也不能正常工作......）。
最后，显示状态和转换的顺序，并检查最终状态是否为接受状态（checkAcceptance）。

---

现在，不要试图优化我写的内容。我知道，定义建模的方式可以改进，我写的许多行可以使用一些高阶 Haskell foo 写得更短。但请帮我解决上面列出的问题（当然也帮我解决问题）。
提前非常感谢。

最后一件事：我正在为我大学的一个研讨会尝试一些 Haskell，所以如果软件架构小组的某个人在谷歌上搜索了我的代码并读到：嗨 :)

Answer 1

问题在于do 表示法和return 函数并没有按照您的想法执行。在 Haskell 中：return 并不表示函数应该结束（即使它最常见于函数的末尾）；它只是意味着参数应该包含在Monad 中。因为应用了所有参数的函数的类型是 (String,String) 编译器认为你试图使用这样的东西：（实际上不会在没有 GHC 扩展的情况下编译，并且如果使用会抛出异常，因为我使用了 undefined )

instance Monad ((,) String) where
  (>>=) = undefined :: (String,a) -> (a -> (String,b)) -> (String,b)
  return = undefined :: a -> (String,a)

但是编译器已经知道(String,String) -> (String,String) 与a -> (String,a) 不匹配，所以它没有检查实例是否存在。 解决这个问题揭示了另一个问题：你在同一个函数中定义了两次 oldStates，这在 Haskell 中不起作用，除非这两个定义在不同的范围内。

这是你的函数修改后可以正常编译，但我没有测试过。

changeState :: String -> String -> [(String, [(Char,String)])] -> (String, String)

changeState startState [] _ = (startState, "")

changeState startState (x:xs) stateTransitions = let
    (currentState, oldStates) = changeState xs startState stateTransitions
    newState = findKey x (findKey currentState stateTransitions)
    oldStates' = (oldStates ++ currentState ++ " -(" ++ [x] ++ ")-> ")
    in (newState, oldStates')

Answer 2

您只需将changeState 函数的第二个子句更改为：

changeState startState (x:xs) stateTransitions =
    let (currentState, oldStates) = changeState xs startState stateTransitions
        newState = findKey x (findKey currentState stateTransitions)
        oldStates2 = (oldStates ++ currentState ++ " -(" ++ [x] ++ ")-> ")
    in (newState, oldStates2)

我们已经 1) 删除了 do，2) 合并了 let 子句，以及 3) 重命名了第二次出现的 oldState 变量到 oldState2。在 Haskell 中，我们不会重新定义变量——我们只是创建一个具有新名称的变量。完整代码在这里：http://lpaste.net/118404

当你写作时：

(new, old) = changeState ...

您是说 changeState 是一个纯函数。如果你用do ... return (...) 定义changeState，你说它是一个单子计算，当你调用它时，你需要在do 块中使用箭头<-：

(new, old) <- changeState ...

既然changeState是一个纯函数（不需要做IO）你还不如把它当作一个纯函数，所以没有理由使用do和return。