调试：无法将预期类型“GHC.Types.Bool”与实际类型“Bool”相匹配

Question

我正在尝试解决 Haskell 的以下练习：

定义函数 exists::(N-> Bool)-> N->Bool，它接收一个谓词 p 和一个自然的 n，并且 returns 如果在 O 和 n 之间有任何数 p 为真，则为真。示例：

exists pair three = True
exists isGreaterThanZero O = False

这段代码在我存在的函数之前：

{-#LANGUAGE GADTs #-}
{-# OPTIONS_GHC -fno-warn-tabs #-}
{-# OPTIONS_GHC -fno-warn-missing-methods #-}

module Naturales where

import Prelude(Show)

data Bool where {   False :: Bool; 
                    True :: Bool
                } deriving Show

{- Data Type of Natural Numbers -}
data N where { O :: N ; 
               S :: N -> N 
            } deriving Show
    
    zero:: N
    zero= O
    
    one:: N
    one = S O
    
    two :: N
    two = S one 
    
    three :: N
    three = S two 
    
    four :: N
    four = S three
    ...

这就是我编写所请求函数的方式 exists 但是当我尝试编译 .hs 代码时说

exists:: (N->Bool)->N->Bool
exists = \p -> \x -> case x of {
            O -> p O;
            (S y) -> if p (S y) then True else existe p y; {- Line 288 -}
        }


    • Couldn't match expected type ‘GHC.Types.Bool’
                  with actual type ‘Bool’
      NB: ‘Bool’ is defined at EstudiandoRecursion.hs:(9,1)-(11,47)
          ‘GHC.Types.Bool’
            is defined in ‘GHC.Types’ in package ‘ghc-prim-0.5.3’
    • In the expression: p (S y)
      In the expression: if p (S y) then True else existe p y
      In a case alternative:
          (S y) -> if p (S y) then True else existe p y
    |
288 |                         (S y) -> if p (S y) then True else existe p y;     |

我想我的函数的逻辑是正确的，但也许我在编写代码时犯了语法错误。

Answer 1

您重新定义了标准 Bool 类型。 Haskell 不知道你自己重新定义的类型实际上和标准类型一样，所以它把它们当作两个独立的类型：Bool（你的）和 GHC.Types.Bool（标准的).

if cond then t else e 表达式仅适用于标准 Bool 类型，不适用于您的自定义类型。因此，您不能在

中使用它

if p (S y) then True else exists p y

因为 p (S y) returns 你自己的习惯 Bool。改为考虑

case p (S y) of
   True  -> True
   False -> exists p y

与 if 不同，它应该可以工作，从您的新类型中选择正确的 True 和 False 构造函数。如果您喜欢大括号和分号，可以使用 case .. of { .. ; ... }。

Answer 2

您正在使用 if … then … else … 表达式。这要求条件是 Bool 类型，这是 builtin Bool，因此定义您自己的 Bool 类型是不够的。

然而，使用 case … of … 子句就足够了，因此可以在 True/False 数据构造函数上进行模式匹配：

exists:: (N -> Bool) -> N -> Bool
exists = \p -> \x -> case x of {
            O -> p O;
            (S y) -> <b>case</b> p (S y) <b>of</b>
                <b>True</b> -> True
                _ -> exists p y
        }

调试：无法将预期类型“GHC.Types.Bool”与实际类型“Bool”相匹配

Debug: Couldn't match expected type ‘GHC.Types.Bool’ with actual type ‘Bool’

debugging

lambda

haskell

case

lambda-calculus