用于组合 (a->a) 函数而不是 (a->b) 的仿函数/应用程序类型类？

Question

我有一个看起来像这样的类型：

newtype Canonical Int = Canonical Int

还有一个函数

canonicalize :: Int  -> Canonical  Int
canonicalize =  Canonical . (`mod` 10)  -- or whatever

（Canonical 类型可能并不重要，它只是用来区分“原始”值和“规范化”值。）

我想创建一些机制，以便规范化函数应用程序的结果。

例如：（编辑：修正虚假定义）

cmap :: (b->Int) -> (Canonical b) -> (Canonical Int)
cmap f (Canonical x) = canonicalize $ f x

cmap2 :: (b->c->Int) -> (Canonical b) -> (Canonical c) -> (Canonical Int)
cmap2 f (Canonical x) (Canonical y) = canonicalize $ f x y

这在表面上类似于 Functor 和 Applicative，但并不完全相似，因为它太专业了：除非“b”是 Int，否则我实际上无法组合函数（按照 Functor/Applicative 的同态法则的要求）。

我的目标是使用现有的库函数/组合器，而不是编写我自己的变体，例如 cmap、cmap2。那可能吗？是否有不同的类型类或不同的方式来构建规范类型，以实现我的目标？

我尝试过其他结构，例如

newtype Canonical a = Canonical { value :: a, canonicalizer :: a -> a }

但这遇到了同样的不可组合性问题，因为我无法将一个规范化器转换为另一个（我只想使用结果类型的规范化器，它始终为Int（或Integral a）

而且我不能像这样强制“仅专业化”，这不是有效的 Haskell：

instance (Functor Int) (Canonical Int) 

（以及类似的变体）

我也试过

newtype (Integral a) => Canonical a = Canonical a -- -XDatatypeContexts
instance (Integral a) => Functor Canonical where
  fmap f (Canonical x) = canonicalize  $ f x

但是 GHC 说 DatatypeContexts 已被弃用，这是一个坏主意，而且更严重的是， 我明白了：

 `Could not deduce (Integral a1) arising from a use of 'C'   
 from the context (Integral a)
 bound by the instance declaration
 [...] fmap :: (a1 -> b) -> (C a1 -> C b)

我认为约束Integral a 实际上不能用于将fmap 约束为(Integral -> Integral) 我希望的方式，这很明显（因为fmap 有两个类型变量）： -(

当然这也不是有效的 Haskell

instance (Integer a) => Functor Canonical where

是否有类似的类型类我可以使用，或者我尝试使用类型类来实现“隐式规范化函数调用的结果”的功能是错误的？

Answer 1

我认为您想要实现的目标可以在 mono-traversable 包中找到，在本例中是 MonoFunctor 类型类。

Answer 2

您的cmap 实际上可以通过fmap 实现。一开始有点奇怪，但(->) 本身只是一个数据类型，实际上等价于Reader。我们可以fmap over 返回结果。

cmap :: (a -> Int) -> a -> (Canonical Int)
cmap = fmap Can

您可以使用相同的模式创建其他 cmap 变体

cmap2 :: (a -> b -> Int) -> a -> b -> (Canonical Int)
cmap2 = fmap (fmap Can)

cmap3 :: (a -> b -> c -> Int) -> a -> b -> c -> (Canonical Int)
cmap3 = fmap (fmap (fmap Can))

现在在代码中看到这通常有点奇怪，在(->) 上看到不太通用的fmap 形式更为常见

instance Functor (r ->) where
  fmap = (.)

cmap :: (a -> Int) -> a -> (Canonical Int)
cmap = (.) Can
cmap f = Can . f

cmap2 :: (a -> b -> Int) -> a -> b -> (Canonical Int)
cmap2   = (.) ((.) Can)
cmap2   = (.) (Can .)
cmap2 f = (Can .) . f

cmap3 :: (a -> b -> c -> Int) -> a -> b -> c -> (Canonical Int)
cmap3   = (.) ((.) ((.) Can))
cmap3   = (.) ((.) (Can .))
cmap3   = (.) ((Can .) .)
cmap3 f = ((Can .) .) . f

显然，这在高阶组合器中变得有点荒谬。 Pointfree 样式可能不是最佳选择。

Answer 3

从你的类型签名来看，这有点像 Identity monad

newtype Identity a = Identity a

instance Monad Identity where
         return x = Identity x
         f >>= (Identity x)  = Identity (f x)

那么在你的例子中 canonicalize = return 和 cmap f x = f >>= (return x)

希望对你有帮助

编辑

我想到的另一个结构是自同构（我学过数学）

如果你有

data Automorphisms a = AMorph (a -> a)

那么你可以有一个 Monoid

instance Monoid Automorphism where
         mempty = id
         mappend = (.)
         mconcat = foldr1 (.)

（我希望 foldr1 是正确的）