haskell - 如何比较我的数据类型(可能是 Rational 或 Float)

Question

假设我的数据类型为:

data Number = Float Float | Rational Integer Integer

为什么这段代码不起作用？

createComparator :: (a -> a -> Bool) -> Number -> Number -> Bool
createComparator comparator (Float f1) (Float f2) = comparator f1 f2
createComparator comparator (Float f) (Rational n d) = comparator f $ (fromIntegral n) / (fromIntegral d)
createComparator comparator (Rational n d) (Float f) = comparator ((fromIntegral n) / (fromIntegral d)) f
-- createComparator comparator (Rational n1 d1) (Rational n2 d2) = ... -- TODO

所以，它基本上采用比较器 (>) 或 (<) 和 2 个数字，并返回 Bool。

例如:0.5 > 1/3 == True

或者，0.2 > 1/3 == False

但是，我收到此错误。

Couldn't match expected type ‘a’ with actual type ‘Float’
  ‘a’ is a rigid type variable bound by
      the type signature for
        createComparator :: (a -> a -> Bool) -> Number -> Number -> Bool
      at Ramadoka/Parser/Number.hs:55:23
Relevant bindings include
  comparator :: a -> a -> Bool
    (bound at Ramadoka/Parser/Number.hs:56:20)
  createComparator :: (a -> a -> Bool) -> Number -> Number -> Bool
    (bound at Ramadoka/Parser/Number.hs:56:3)
In the first argument of ‘comparator’, namely ‘f1’
In the expression: comparator f1 f2

我可以通过以下方式让它发挥作用:

(|>|) :: Number -> Number -> Bool
(Float f1) |>| (Float f2) = f1 > f2
(Float f) |>| (Rational n d) = f > (fromIntegral n) / (fromIntegral d)
(Rational n d) |>| (Float f) = (fromIntegral n) / (fromIntegral d) > f
r1@(Rational _ _) |>| r2@(Rational _ _) = rationalCompare r1 r2 == GT

(|<|) :: Number -> Number -> Bool
(Float f1) |<| (Float f2) = f1 < f2
(Float f) |<| (Rational n d) = f < (fromIntegral n) / (fromIntegral d)
(Rational n d) |<| (Float f) = (fromIntegral n) / (fromIntegral d) < f
r1@(Rational _ _) |<| r2@(Rational _ _) = rationalCompare r1 r2 == LT

不过，我仍然更喜欢:

(|>|) = createComparator (>)
(|<|) = createComparator (<)

Answer 1

警告:我手边没有 Haskell 编译器，所以我无法检查我的工作

简单的答案是将a更改为Float。

让我们一起玩，看看会发生什么。你的类型签名告诉我的是，如果我为任何可能的 a 提供一个函数 a -> a -> Bool ，你的函数就会工作。即使我给你一些可笑的函数，例如String -> String -> Bool，你的函数也会完成它的工作。请注意，对于任何多态 a ，都有一个隐式 forall，Haskell 隐藏在类型签名的左侧。

“对于您选择的任何a，您可以给我一个a -> a -> Bool，我会给您一个Number -> Number -> bool 型。”

forall a. (a -> a -> Bool) -> Number -> Number -> Bool

这可能不是你想说的。您希望比较器的类型为 Float -> Float -> Bool，因为您要将自己的个人 Rational 转换为 Float。

如果你想弄清楚如何获得你最初想要的多态性，你要寻找的是 higher rank types .

因此，在我们开始此旅程之前，请在文件顶部启用排名 n 类型。

{-# LANGUAGE RankNTypes #-}

您可能想说一些更接近以下内容的内容，其中涉及将 forall 移动到一组括号中。

“如果你给我一个函数，对于任何选择的类型a，我可以比较两者并给你一个Bool，然后我可以给你一个数字->数字-> bool 。”

(forall a. a -> a -> Bool) -> Number -> Number -> Bool

将 forall 移动到一层括号中就是所谓的 2 级类型。如果您嵌套另一层，您将获得排名 3，依此类推。

这仍然不是您想要的，因为类型约束太强大了。 对于所有的a。 a -> a -> Bool 必须始终为 true 或 false 才能适用于所有可能的 a。您可能想要的是类型类约束来缩小您关心的 a 范围。

(forall a. Ord a => a -> a -> Bool) -> Number -> Number -> Bool

在您的特定情况下，即使这基本上是多余的，您也可以像前面提到的那样使用Float，因为这最终是forall a. Ord a => a -> a -> Bool 将专门用于。

如果你有这个作为你的签名，我想你已经完成了(现在手头没有 Haskell 编译器)。