Question

这是个人练习，可以更好地理解Haskell类型系统的局限性。我想创建一个最通用的函数，它可以将一些函数应用于2个入口元组中的每个条目，例如：

applyToTuple fn (a,b) = (fn a, fn b)

我正在尝试使此功能在以下每种情况下都有效：

(1) applyToTuple length ([1,2,3] "hello")
(2) applyToTuple show ((2 :: Double), 'c')
(3) applyToTuple (+5) (10 :: Int, 2.3 :: Float)

因此，对于length，对中的项目必须为Foldable，以表明它们必须是Show等的实例。

使用RankNTypes我可以采取一些方式，例如：

{-# LANGUAGE RankNTypes #-}
applyToTupleFixed :: (forall t1. f t1 -> c) -> (f a, f b) -> (c, c)
applyToTupleFixed fn (a,b) = (fn a, fn b)

这允许可以在一般上下文f上工作的函数应用于该上下文中的项。 (1)适用于此，但(2)和(3)中的元组项目没有上下文，因此它们不起作用（无论如何，3将返回不同的类型）。我当然可以定义一个上下文来放置项目，例如：

data Sh a = Show a => Sh a
instance Show (Sh a) where show (Sh a) = show a

applyToTuple show (Sh (2 :: Double), Sh 'c')

让其他示例正常工作。我只是想知道是否有可能在Haskell中定义这样的泛型函数而不必将元素包装在元组中或者给applyToTuple一个更具体的类型签名。

Answer 1

您与最后一个非常接近，但您需要添加约束：

{-# LANGUAGE RankNTypes      #-}
{-# LANGUAGE ConstraintKinds #-}
import Data.Proxy

both :: (c a, c b)
     => Proxy c
        -> (forall x. c x => x -> r)
        -> (a, b)
        -> (r, r)
both Proxy f (x, y) = (f x, f y)

demo :: (String, String)
demo = both (Proxy :: Proxy Show) show ('a', True)

Proxy是通过模糊检查所必需的。我认为这是因为它不会知道从函数中使用哪个约束部分。

为了将其与其他情况统一起来，您需要允许空约束。这可能是可能的，但我不确定。您不能部分应用类型系列，这可能会使它有点棘手。

这比我想象的要灵活得多：

demo2 :: (Char, Char)
demo2 = both (Proxy :: Proxy ((~) Char)) id ('a', 'b')

我不知道你到目前为止可以部分地应用类型相等，哈哈。

不幸的是，这不起作用：

demo3 :: (Int, Int)
demo3 = both (Proxy :: Proxy ((~) [a])) length ([1,2,3::Int], "hello")

对于列表的特定情况，我们可以使用IsList中的GHC.Exts来实现此功能（IsList通常与OverloadedLists扩展名一起使用，但我们这里不需要）：

demo3 :: (Int, Int)
demo3 = both (Proxy :: Proxy IsList) (length . toList) ([1,2,3], "hello")

当然，最简单（甚至更一般）的解决方案是使用(a -> a') -> (b -> b') -> (a, b) -> (a', b')类型的函数（如bimap from Data.Bifunctor或(***) from Control.Arrow），并将其赋予相同的函数两次：

λ> bimap length length ([1,2,3], "hello")
(3,5)

统一问题中的所有三个例子

好的，经过一些思考和编码后，我想出了如何至少将你给出的三个例子统一到一个函数中。它可能不是最直观的东西，但似乎有效。诀窍是，除了上面的内容之外，如果我们给类型系统以下限制，我们允许函数返回两种不同的结果类型（结果对的元素可以是不同类型）：

两个结果类型必须与双参数类型类给出的相应输入类型有关（我们可以将一个参数类型类看作一个类型的逻辑谓词，我们可以看一个两个参数类型类捕获两种类型之间的二元关系。）

对applyToTuple (+5) (10 :: Int, 2.3 :: Float)之类的内容来说，这是必要的，因为它会让您回到(Int, Float)。

有了这个，我们得到：

{-# LANGUAGE RankNTypes            #-}
{-# LANGUAGE ConstraintKinds       #-}
{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE MultiParamTypeClasses #-}
import Data.Proxy

import GHC.Exts

both :: (c a, c b
        ,p a r1  -- p is a relation between a and r1
        ,p b r2  -- and also a relation between b and r2
        )
     => Proxy c
        -> Proxy p
        -> (forall r x. (c x, p x r) => x -> r) -- An input type x and a corresponding
                                                -- result type r are valid iff the p from
                                                -- before is a relation between x and r,
                                                -- where x is an instance of c
        -> (a, b)
        -> (r1, r2)
both Proxy Proxy f (x, y) = (f x, f y)

Proxy p表示输入和输出类型之间的关系。接下来，我们定义一个便利类（据我所知，它已经不存在）：

class r ~ a => Constant a b r
instance Constant a b a      -- We restrict the first and the third type argument to
                             -- be the same

这可以让我们在结果类型保持不变的情况下使用both，方法是将Constant部分应用于我们知道的类型（我也不知道你现在可以部分应用类型类我正在为这个答案学到很多东西，哈哈）。例如，如果我们知道两个结果中都是Int：

example1 :: (Int, Int)
example1 =
  both (Proxy :: Proxy IsList)         -- The argument must be an IsList instance
       (Proxy :: Proxy (Constant Int)) -- The result type must be Int
       (length . toList)
       ([1,2,3], "hello")

同样适用于您的第二个测试用例：

example2 :: (String, String)
example2 =
  both (Proxy :: Proxy Show)              -- The argument must be a Show instance
       (Proxy :: Proxy (Constant String)) -- The result type must be String
       show
       ('a', True)

第三个是有趣的地方：

example3 :: (Int, Float)
example3 =
  both (Proxy :: Proxy Num)  -- Constrain the the argument to be a Num instance
       (Proxy :: Proxy (~))  -- <- Tell the type system that the result type of
                             --    (+5) is the same as the argument type.
       (+5)
       (10 :: Int, 2.3 :: Float)

这里输入和输出类型之间的关系实际上只比其他两个例子稍微复杂一点：我们说输入和输出类型必须相同（从而{ {1}}）。换句话说，在这种特殊情况下，我们的关系是平等关系。

Answer 2

你想要的是一个类型为

的函数

applyToTuple :: (a -> b) -> (c, d) -> (b, b)

编译器将检查a，c和d是否在同一类型类中。遗憾的是，据我所知，这是不可能的（尽管某处可能存在扩展）。当你将某个类型类的函数传递给另一个函数时，它的类型将成为它应用的第一个类型（从GHC观察）：

applyToTuple f (x, y) = (f x, f y)

的派生类型为applyToTuple :: (t -> t1) -> (t, t) -> (t1, t1)。使用show进行测试会显示以下结果：

λ> applyToTuple show (8, 9)
("8","9")
λ> applyToTuple show (8, [8,9])

<interactive>:5:14:
    No instance for (Show t0) arising from a use of `show'
    The type variable `t0' is ambiguous
    Possible fix: add a type signature that fixes these type variable(s)
    Note: there are several potential instances:
      instance Show Double -- Defined in `GHC.Float'
      instance Show Float -- Defined in `GHC.Float'
      instance (Integral a, Show a) => Show (GHC.Real.Ratio a)
        -- Defined in `GHC.Real'
      ...plus 28 others
    In the first argument of `applyToTuple', namely `show'
    In the expression: applyToTuple show (8, [8, 9])
    In an equation for `it': it = applyToTuple show (8, [8, 9])

<interactive>:5:20:
    No instance for (Num [t0]) arising from the literal `8'
    Possible fix: add an instance declaration for (Num [t0])
    In the expression: 8
    In the second argument of `applyToTuple', namely `(8, [8, 9])'
    In the expression: applyToTuple show (8, [8, 9])

<interactive>:5:24:
    No instance for (Num t0) arising from the literal `8'
    The type variable `t0' is ambiguous
    Possible fix: add a type signature that fixes these type variable(s)
    Note: there are several potential instances:
      instance Num Double -- Defined in `GHC.Float'
      instance Num Float -- Defined in `GHC.Float'
      instance Integral a => Num (GHC.Real.Ratio a)
        -- Defined in `GHC.Real'
      ...plus three others
    In the expression: 8
    In the expression: [8, 9]
    In the second argument of `applyToTuple', namely `(8, [8, 9])'

但是，您可以执行applyToTuple' f1 f2 (x, y) = (f1 x, f2 y)之类的操作。我认为您可以使用Template Haskell将其转换为您想要的内容。

Haskell：如何创建将函数应用于元组项的最通用函数

2 个答案:

统一问题中的所有三个例子