这个多参数类型类可以简化吗？

Question

我创建了这个类型类以使 Divisible 函子（“Applicative 的逆变模拟”-https://hackage.haskell.org/package/contravariant-1.2/docs/Data-Functor-Contravariant-Divisible.html）可用于具有多个参数的函数，其方式与 Applicative 函子非常相似。

这个想法是你写unFunc |$| fa |*| fb |*| fc，其中：

unFunc :: z -> (a, (b, (c, ())))
fa :: f a
fb :: f b
fc :: f c

得到一个f z，对于一些Divisible函子f。 |$| 是来自Data.Functor.Contravariant.Divisible 的divide，|*| 是来自我下面的代码的dApply：

{-# LANGUAGE FlexibleContexts
           , FlexibleInstances
           , FunctionalDependencies
           , MultiParamTypeClasses
           , TypeFamilies
           , UndecidableInstances
  #-}

import Control.Applicative ((<$>), (<*>), Applicative)
import Data.Functor.Contravariant.Divisible
  ( Divisible(divide, conquer)
  , divided
  )

result :: (b -> c) -> (a -> b) -> (a -> c)
result = fmap

class Divisible f => DivisibleApply f t z r | f t z -> r, r t -> f, r t -> z
  where dApply :: (f (a, t) -> f z) -> f a -> r

instance Divisible f => DivisibleApply f () z (f z)
  where dApply = (. flip divided conquer)

instance DivisibleApply f b z r' => DivisibleApply f (a, b) z (f (a, b) -> f z)
  where dApply = flip (result.result) divided

这确实有效！但是DivisibleApply 类似乎太复杂了。我实际上只是在t 参数上“切换”，我实际上希望在f 和z 中完全多态；它们只是类参数，因为实例需要根据它们实例化 r。

最初我尝试使用类型族；该类只有一个参数t，而r 的角色由关联类型承担。我遇到的问题（以及许多其他变体）是，即使我可以让它接受类和实例，将它应用于多个参数时也会因类型变量不明确而失败。我相信这是因为我没有与haskell 沟通我一直使用相同的f。

是否有可能在保持unFunc |$| fa |*| fb |*| fc 用法的同时恢复dApply 的更简单类型？

（我的最终目标是使用它来创建一个包含 both Applicative 和 Divisible 的类型类；给定一对函数 func :: a -> b -> c -> z 和 unFunc :: z -> (a, (b, (c, ()))) 应该是可能的制作一个函数f a -> f b -> f c-> f z 只知道f 是协变的或逆变的，却不知道是哪个。因此我为什么要镜像Applicative 用法的结构）

Answer 1

我认为这里的问题是“Applicative 样式”与Divisibles 的组合方式非常匹配，所以如果你坚持使用，你就没有自然类型来提供中间结果完全是unFunc |$| fa |*| fb |*| fc 格式。毕竟最直接的写法是

unFunc `contramap` (fa `divided` (fb `divided` (fc `divided` conquered)))

它的关联方式与 Applicative 风格完全相反。

无论如何强制它变成那种格式会导致代码拾取在我看来类似于Text.Printf 的可变长度参数列表重载技巧 - 这肯定表明您正在与类型作斗争。

相反，我建议稍微更改用法，以便它适合Applicative 和Divisible 的更自然类型。也许是这样的：

func |$| fa |*| fb |*| fc |!| unFunc

显示相似之处的示例代码（我留给您实际统一它们。）我还更改了 unFunc 的类型以更好地适应这种用法。

import Data.Functor.Contravariant
import Data.Functor.Contravariant.Divisible
import Control.Applicative

(|$|) :: Divisible f => t -> f a -> f a
f |$| fa = fa -- For Divisibles, this end does nothing

(|*|) :: Divisible f => f a -> f b -> f (a, b)
fa |*| fb = divided fa fb

(|!|) :: Contravariant f => f b -> (a -> b) -> f a
fz |!| unFunc = contramap unFunc fz

(<!>) :: Applicative f => f z -> t -> f z
fz <!> _ = fz -- For Applicatives, this end does nothing

-- These two functions have the same type except for one using Divisible and the other Applicative

divide3 :: Divisible f => (a -> b -> c -> z) -> (z -> ((a, b), c)) -> f a -> f b -> f c -> f z
divide3 func unFunc fa fb fc = func |$| fa |*| fb |*| fc |!| unFunc

apply3 :: Applicative f => (a -> b -> c -> z) -> (z -> ((a, b), c)) -> f a -> f b -> f c -> f z
apply3 func unFunc fa fb fc = func <$> fa <*> fb <*> fc <!> unFunc

我还可以看到另一种方法，您可以删除初始 |$| 部分并使用 Applicatives 支持组合比 Divisibles 更好地支持函数应用这一事实，因此您可以使用相同的方法对于Applicatives，就像我在上面用于Divisibles 一样。