Объединить m-арную функцию с n-арной функцией в одну (m+n)-арную функцию, возвращающую пару их результатов

Как указывает Виллем Ван Онсем в комментариях, проблема с вашим вопросом заключается в том, что технически каждая функция в Haskell принимает ровно один параметр. Я знаю, что вы имеете в виду, и я знаю, что вы хотите сделать, но нет причин, по которым (+) не может быть просто функцией с одним аргументом, которая возвращает функцию, а не функцию с двумя аргументами. В самом деле, если мы определим экземпляр Num для чего-то вроде Int -> Int, то вполне возможно, что (+) является функцией с тремя аргументами!

С другой стороны, только потому, что количество аргументов нельзя вывести, это не означает, что вы обречены. Если вы согласны дать GHC несколько подсказок, вы можете делать все, что хотите, на уровне типа. Рассмотрим следующее:

data Nat = Zero | Succ Nat
type One = Succ Zero
type Two = Succ One
type Three = Succ Two
type Four = Succ Three

class NFun m n f g where
  type family FunT m n f g
  h :: f -> g -> FunT m n f g

instance NFun m n x y => NFun (Succ m) n (a -> x) y where
  type FunT (Succ m) n (a -> x) y = a -> FunT m n x y
  h f g a = h @m @n (f a) g

instance NFun Zero n x y => NFun Zero (Succ n) x (a -> y) where
  type FunT Zero (Succ n) x (a -> y) = a -> FunT Zero n x y
  h f g a = h @Zero @n f (g a)

instance NFun Zero Zero x y where
  type FunT Zero Zero x y = (x,y)
  h = (,)

(Возможно, это можно сделать красивее, используя GHC TypeLits, но у меня всегда возникают небольшие проблемы с выводом индукции, поэтому я сам вычислял натуральные числа.)

Здесь я определил класс типов NFun, который принимает два числовых типа, указывающих, сколько аргументов будет принимать функция. Первый экземпляр предоставляет аргументы первой функции, а второй экземпляр предоставляет аргументы второй функции. Последний экземпляр объединяет результаты.

Вы можете использовать его следующим образом:

f x y z = x + 10*y + 100*z
g x y = x + 10*y

h @Three @Two f g 1 2 3 4 5 == (321, 54)

Если функция не является конкретным типом, арность функции (если не учитывать тот факт, что, строго говоря, каждая функция имеет арность, равную единице), может быть переменной. Действительно, хороший пример — printf::PrintfType r => String -> r.

Это кажется простой функцией. Но есть проблема: r здесь может быть любой экземпляр PrintfType, а у нас в качестве экземпляров:

instance PrintfType a ~ () => PrintfType (IO a) where
    -- ...

instance IsChar c => PrintfType [c] where
    -- ...

instance (PrintfArg a, PrintfType r) => PrintfType (a -> r) where
    -- ...

Первые два не так интересны. Последний есть. Действительно, это означает, что он может возвращать другую функцию.

Это означает, что можно использовать printf как:

printf "foo"             :: String
printf "foo %i" 14       :: String
printf "foo %i %i" 14 25 :: String

Они реализовали своего рода вариативную функцию, в которой количество параметров зависит от того, как вы используете printf.

Хотя я не совсем доволен printf, поскольку он не очень «безопасен» по сравнению со многими другими функциями Haskell, он демонстрирует, как можно создавать функции с переменным числом переменных. Например, можно передать слишком много или слишком мало параметров, и %i не гарантируется получение целочисленного или числового значения, поэтому есть лучшие способы форматирования строк.

Но независимо от того, количество параметров не зависит от самой функции, поэтому вы можете вывести это не с точки зрения функции, а с точки зрения того, как она используется. Поэтому, если только типы не являются конкретными в функции, если используются классы типов, уже не так просто определить арность функции и, следовательно, «слить» две функции вместе.