在 Haskell 中实现函数加法

Question

我在 Haskell 中得到了一个谜题，

f 有两个函数，函数a 和函数b。函数 a 接受 n_a 输入并返回 Num 类型，函数 b 接受 n_b 输入并返回Num 类型。 f 返回一个新的 n_a+n_b 函数，它将 a 应用于第一个 n _a 个参数，n_b 到其余参数并返回它们的总和。

在数学中我会这样写：

我在 Haskell 中第一次天真的尝试是：

f a b = flip ((+) . a) . b

但这只有在 a 是一元函数时才有效。

在这之后，我想了很久这个谜题，甚至无法想出我应该如何做到这一点的想法。这是很长时间以来我第一次对 Haskell 感到如此困惑。

我该如何解决这个难题？这个谜题有解决方案吗？ （我的一个朋友给了我这个谜题，我不相信他们当时有真正的解决方案）

Answer 1

这是一种非常简单的方法，它使用在数字类型中单态工作的类型族（例如，专用于 Int）。我们需要一些扩展：

{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE InstanceSigs #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE TypeFamilies #-}

函数f将定义在一个类型类中：

class VarArgs r s where
  type F r s
  f :: r -> s -> F r s

我们将处理以下情况。如果第一个函数的类型是 a :: Int -> r 形式，我们将使用以下实例来吞噬参数 x 并将其提供给 a：

instance VarArgs r s => VarArgs (Int -> r) s where
  type F (Int -> r) s = Int -> F r s
  f :: (Int -> r) -> s -> Int -> F r s
  f a b x = f (a x) b

这具有递归 a 的类型的效果，直到它的形式为 Int。然后，我们将使用类似的实例来递归 b :: Int -> s 类型：

instance VarArgs Int s => VarArgs Int (Int -> s) where
  type F Int (Int -> s) = Int -> F Int s
  f :: Int -> (Int -> s) -> Int -> F Int s
  f a b x = f a (b x)

最终，这两个函数都将简化为a, b :: Int类型的0元函数，我们可以使用终端实例：

instance VarArgs Int Int where
  type F Int Int = Int
  f :: Int -> Int -> Int
  f a b = a + b

这里有一个小测试来证明它有效：

times2 :: Int -> Int -> Int
times2 x y = x * y
times3 :: Int -> Int -> Int -> Int
times3 x y z = x * y * z

foo :: [Int]
foo = [ f times2 times2 1 2 3 4
      , f times2 times3 1 2 3 4 5
      , f times3 times2 1 2 3 4 5
      , f times3 times3 1 2 3 4 5 6]

并将其加载到 GHCi 中会得到：

> foo
[14,62,26,126]
>

将其概括为任何Num 类型的多态似乎并不简单。将 Int 类型替换为受约束的 Num n 类型会导致有关冲突族实例声明的错误。

Answer 2

这很简单——在我看来，这比 @K.A.Buhr 的类型族方法要简单得多——如果你调整 n 元函数的表示，而不是使用 n 元函数的一元函数em>n 维向量。

{-# LANGUAGE GADTs #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}

import Prelude hiding (splitAt)
import Data.Bifunctor

常见的怀疑对象：（类型级）自然数、它们的（值级）单例、类型级加法和向量。

data Nat = Z | S Nat
data Natty n where
    Zy :: Natty Z
    Sy :: Natty n -> Natty (S n)
type family n + m where
    Z + m = m
    S n + m = S (n + m)

data Vec n a where
    Nil :: Vec Z a
    (:>) :: a -> Vec n a -> Vec (S n) a

splitAt 需要运行时 Natty - 它需要在运行时知道在哪里分割向量 - 以及至少与 Natty 一样长的向量。

splitAt :: Natty n -> Vec (n + m) a -> (Vec n a, Vec m a)
splitAt Zy xs = (Nil, xs)
splitAt (Sy n) (x :> xs) =
    let (ys, zs) = splitAt n xs
    in (x :> ys, zs)

那么您的f（我称之为splitApply）是splitAt 的直接应用。

splitApply :: Natty n -> (Vec n a -> b) -> (Vec m a -> c) -> Vec (n + m) a -> (b, c)
splitApply at f g xs = bimap f g $ splitAt at xs

（我没有费心展示“添加结果”部分，因为它太简单了，以至于我写起来很无聊。你可以争辩说，因为 Hask 是一个幺半群类别，@ 987654331@ 无论如何都代表一种加法。）