为什么这个haskell代码失败了

首先，我不能完全理解错误信息，所以我只能使用一个模棱两可的问题标题

这段代码来自第9频道关于haskell编程的第8章

我试图通过GHC运行这段代码，我编写了

-- Functional parsing library from chapter 13 of Programming in Haskell,
-- Graham Hutton, Cambridge University Press, 2016.

module Parsing (module Parsing, module Control.Applicative) where
import Data.Typeable
import Control.Applicative
import Data.Char

-- Basic definitions

newtype Parser a = P (String -> [(a,String)])

parse :: Parser a -> String -> [(a,String)]
parse (P p) inp = p inp

item :: Parser Char
item = P (\inp -> case inp of
                     []     -> []
                     (x:xs) -> [(x,xs)])

-- Sequencing parsers

instance Functor Parser where
   -- fmap :: (a -> b) -> Parser a -> Parser b
   fmap g p = P (\inp -> case parse p inp of
                            []        -> []
                            [(v,out)] -> [(g v, out)])

instance Applicative Parser where
   -- pure :: a -> Parser a
   pure v = P (\inp -> [(v,inp)])

   -- <*> :: Parser (a -> b) -> Parser a -> Parser b
   pg <*> px = P (\inp -> case parse pg inp of
                             []        -> []
                             [(g,out)] -> parse (fmap g px) out)

instance Monad Parser where
   -- (>>=) :: Parser a -> (a -> Parser b) -> Parser b
   p >>= f = P (\inp -> case parse p inp of
                           []        -> []
                           [(v,out)] -> parse (f v) out)

-- Making choices

instance Alternative Parser where
   -- empty :: Parser a
   empty = P (\inp -> [])

   -- (<|>) :: Parser a -> Parser a -> Parser a
   p <|> q = P (\inp -> case parse p inp of
                           []        -> parse q inp
                           [(v,out)] -> [(v,out)])

return' :: a -> Parser a
return' v = \inp -> [(v, inp)]

p' :: Parser (Char, Char)
p' = do 
    x <- item
    item
    y <- item
    return' (x, y)

main = print (p' "123")

看起来这个型号有点问题，我试过了

main = print (item "123")

它也不起作用

然而，当我简单地删除

解析器的定义，并用上一张幻灯片中提到的定义替换它们时

type Parser a = String -> [(a, String)]

item :: Parser Char
item = \inp -> case inp of
                    [] -> []
                    (x:xs) -> [(x,xs)]

return' :: a -> Parser a
return' v = \inp -> [(v, inp)]

main = print (item "123")

它只处理输出
[（'1'，'23”）]
，我在这里感到困惑

顺便说一句，我发现在评论部分一个leomm问了和我一样的问题，他后来发现了这个问题。但是我就是不能解决这个问题。
newtype
需要构造函数，而
type
不需要。如果我们想用
newtype
替换
type
，我们需要添加一个构造函数，
P
，例如，对
解析器的任何用法
type；为了解析
Parser
，我们实现了
parse

从第二个示例代码开始，我们将

newtype Parser a = P (String -> [(a, String)])

parse :: Parser a -> String -> [(a,String)]
parse (P p) inp = p inp 

item :: Parser Char
item = P (\inp -> case inp of
                [] -> []
                (x:xs) -> [(x,xs)])

main = print (parse item "12345")

现在让我们实现您的特殊解析器
p
。为了使用
do
，我们实现了Monad实例

我们在代码中添加了：

instance Monad Parser where
  -- (>>=) :: Parser a -> (a -> Parser b) -> Parser b
  p >>= f = P (\inp -> case parse p inp of
                       []        -> []
                       [(v,out)] -> parse (f v) out)
  -- return :: a -> Parser a
  return v = P (\inp -> [(v, inp)])

p :: Parser (Char, Char)
p = do  
  x <- item
  item
  y <- item
  return (x, y)

在我看来，ghc中的错误信息相当广泛，但必须仔细阅读；使用数据类型时还必须非常小心。
newtype
需要构造函数，而
type
不需要。如果我们想用
newtype
替换
type
，我们需要添加一个构造函数，
P
，例如，对
解析器的任何用法
type；为了解析
Parser
，我们实现了
parse

从第二个示例代码开始，我们将

newtype Parser a = P (String -> [(a, String)])

parse :: Parser a -> String -> [(a,String)]
parse (P p) inp = p inp 

item :: Parser Char
item = P (\inp -> case inp of
                [] -> []
                (x:xs) -> [(x,xs)])

main = print (parse item "12345")

现在让我们实现您的特殊解析器
p
。为了使用
do
，我们实现了Monad实例

我们在代码中添加了：

instance Monad Parser where
  -- (>>=) :: Parser a -> (a -> Parser b) -> Parser b
  p >>= f = P (\inp -> case parse p inp of
                       []        -> []
                       [(v,out)] -> parse (f v) out)
  -- return :: a -> Parser a
  return v = P (\inp -> [(v, inp)])

p :: Parser (Char, Char)
p = do  
  x <- item
  item
  y <- item
  return (x, y)

在我看来，ghc中的错误信息相当广泛，但必须仔细阅读；使用数据类型时也必须非常小心。
项
是一个
解析器
。我认为您需要
解析item“123”
而不是只解析
item“123”
p'
属于
解析器（Char，Char）
类型，这是一种
新类型
，因此它被认为是与您期望的函数类型分开的类型，即使它与之同构。正如MathematicalArchid指出的那样，您可以使用
parse p'
来恢复所需的函数。
item
是一个
解析器。我认为您需要
解析item“123”
而不是只解析
item“123”
p'
属于
解析器（Char，Char）
类型，这是一种
新类型
，因此它被认为是与您期望的函数类型分开的类型，即使它与之同构。正如MathematicalArchid指出的，您可以使用
parse p'
来恢复所需的函数。