Что происходит, когда я сочиняю * С + в Haskell?

(*) и (+) оба имеют сигнатуру типа Num a => a -> a -> a Теперь, если вы их сочините, вы получите что-то обалденное.

(*) . (+) :: (Num (a -> a), Num a) => a -> (a -> a) -> a -> a

Это потому, что (*) и (+) ожидают два "аргумента".

(+) с одним аргументом получает функцию. Оператор . ожидает эту функцию (a -> a, которую вы видите).

Вот значение (*) . (+)

                                       x     f          y
 (*) . (+) :: (Num (a -> a), Num a) => a -> (a -> a) -> a -> a

(*) . (+) отображение x f y в ((x +) * f) y, где f - функция от a до a, которая также является числом. Причина (*) функция ожидает, что типы будут совпадать, пока она ожидает два аргумента, но эта функция должна быть числом, потому что (*) работает только с числами.

На самом деле, эта функция вообще не имеет смысла.

Сначала некоторые расширения:

{-# LANGUAGE FlexibleContexts, FlexibleInstances, TypeSynonymInstances #-}

Как показывают другие ответы, ваша функция -

weird :: (Num (a -> a), Num a) => a -> (a -> a) -> a -> a
weird x g = (x +) * g

Но эта функция имеет не странную семантику.

Существует понятие списков различий. Соответственно, существует понятие разностных целых чисел. Я видел, что они используются только в зависимости от типизации (например, здесь , но это не единственный случай). Соответствующая часть определения является

instance Enum DiffInt where
    toEnum   n = (n +)
    fromEnum n = n 0

instance Num DiffInt where
    n + m = n . m
    n * m = foldr (+) id $ replicate (fromEnum n) m

В этом нет особого смысла. Haskell, но может быть полезен с зависимыми типами.

Теперь мы можем написать

test :: DiffInt
test = toEnum 3 * toEnum 4

Или

test :: DiffInt
test = weird 3 (toEnum 4)

В обоих случаях fromEnum test == 12.

EDIT

Можно избежать использования расширения TypeSynonymInstances:

{-# LANGUAGE FlexibleContexts, FlexibleInstances #-}

weird :: (Num (a -> a), Num a) => a -> (a -> a) -> a -> a
weird x g = (x +) * g

instance (Enum a, Num a) => Enum (a -> a) where
    toEnum   n = (toEnum n +)
    fromEnum n = fromEnum $ n (toEnum 0)

instance (Enum a, Num a) => Num (a -> a) where
    n + m = n . m
    n * m = foldr (+) id $ replicate (fromEnum n) m

type DiffInt = Int -> Int

Как и прежде, мы можем написать

test' :: DiffInt
test' = weird 3 (toEnum 4)

Но теперь мы можем также написать

-- difference ints over difference ints
type DiffDiffInt = DiffInt -> DiffInt

test'' :: DiffDiffInt
test'' = weird (toEnum 3) (toEnum (toEnum 4))

И

main = print $ fromEnum $ fromEnum test'

Отпечатки 12.

EDIT2 добавлены лучшие ссылки.

Пусть:

m = (*)
a = (+)

Затем

(m.a) x = (m (a x)) = m (a x) 

Теперь m ожидает Num a в качестве параметра, с другой стороны (a x), т. е. (x +) является унарной функцией (a -> a) по определению (+). Я предполагаю, что произошло то, что GHC пытается объединить эти два типа так, чтобы, если у вас есть тип, который является одновременно числом и унарной функцией, m может взять число и унарную функцию и вернуть унарную функцию, так как они считаются одним и тем же типом.

Как указал @Сид, это объединение не сделает смысл для любых нормальных типов чисел, таких как целые числа и числа с плавающей запятой.

Здесь есть хорошие ответы, но позвольте мне быстро указать на несколько шагов, где вы ошиблись.

Во-первых, правильное определение состава функций -

(f . g) x = f (g x)

Вы пропустили x на LHS. Далее, вы должны помнить, что в Haskell h x y это то же самое, что и (h x) y. Итак, вопреки тому, что вы ожидали,

((*) . (+)) 1 2 = (((*) . (+)) 1) 2 = ((*) ((+) 1)) 2 = ((+) 1) * 2,

И теперь вы видите, почему это не удается. Кроме того,

((*) . (+)) 1 (\x -> x + 1) 1

Не работает, потому что ограничение Num (Int -> Int) не выполняется.