Смущенный функциональный состав в Haskell

Question

Я знаю, что (.) f g x = f (g x). Предположим, что f имеет тип Int -> Int, g имеет тип Int -> Int -> Int. Теперь пусть h будет определяться h x y = f (g x y). Какое из следующих утверждений истинно и почему (почему бы и нет)?

a. h = f . g

b. h x = f . (g x)

c. h x y = (f . g) x y

Предположительно, только b. это правда, а остальные ложны. Я бы подумал. и b. эквивалентны ... a. говорит, что две функции равны. Две функции равны только тогда, когда я добавляю аргумент в конец обеих сторон, он все равно будет равен. Поэтому я получаю h x = f . g x. Теперь (.) является оператором, поэтому функциональное приложение имеет приоритет над ним, поэтому f . g x = f . (g x), что и b.

Answer 1

Это выглядит как домашнее задание, поэтому я не буду давать ответ, какой из них правильный.

Вы считаете a и b идентичными неправильно. Если f . g применяется к x, вы получите (из определения (.))

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

Но b является f . (g x), который не расширяется до f (g x). Если вы следуете b с помощью определения (.), вы увидите смысл в комментариях других.

Answer 2

первоначальное определение композиции функций является немного запутанным, так что я буду писать это по-другому:

f . g = \a -> f (g a) 

Это означает, что f . g возвращает функцию, которая первая применяет аргумент g, затем применяет результат это до f. Это также ясно, в сигнатуре типа:

(.) :: (b -> c) -> (a -> b) -> (a -> c) 

Теперь для функции Н, он имеет тип что-то вроде h :: a -> a -> a. Помните, что -> является право-ассоциативным, поэтому тип может быть записан как h :: a -> (a -> a). По существу, h :: a -> b, хотя этот тип вызовет ошибку, потому что b и a являются необратимыми. (.) только позволит один аргумент, который будет применен к первой функции, так:

-- One could write, 
h x y = f (g x y) 
-- But One could also write 
h x = f . g x 
-- Or, more clearly: 
h x = (f) . (g x) 

Это происходит потому, что функции Haskell являются кэрри, поэтому мы можем применить некоторые аргументы g без полной оценки его.

Если мы представим себе, что произойдет, если мы применили (.) визуально, то упростить, мы можем увидеть, как это работает:

h x = \a -> f ((g x) a) 
h x = \a -> f (g x a) 
h x a = f (g x a) 

Так что да, б ответ. Это связано с тем, что (.) разрешает применять только один аргумент к первой функции перед переходом к следующему.

Теперь вы можете справиться с другими неправильными решениями, упростив, как и я. Это не слишком сложно.