Действительно ли функциональная монада предлагает нечто большее, чем аппликативный функтор функции? Если да, то?

Когда вы реализуете join таким образом, вы используете знания о типе функции сверх того, что дает Applicative. Эти знания закодированы в использовании ($). Это оператор приложения, который является сутью функции. То же самое происходит с вашим примером списка: вы используете concat, который основан на знании природы списков.

В общем, если вы можете использовать знание конкретной монады, вы можете выражать вычисления любой мощности. Например, с Maybe вы можете просто сопоставить его конструкторы и выразить что-либо таким образом. Когда LYAH говорит, что монада более мощная, чем аппликативная, это означает как абстракции, не применимые к какой-либо конкретной монаде.

edit2: Проблема с вопросом в том, что он расплывчатый. Он использует понятие (более мощное), которое вообще не определено и оставляет читателя в догадках относительно его значения. Таким образом, мы можем получить только бессмысленные ответы. Конечно, можно закодировать все, что угодно, используя весь имеющийся в нашем распоряжении арсенал Haskell. Это пустое заявление. И вопрос не в этом.

Насколько я понимаю, проясненный вопрос: использование методов из Monad / Applicative / Functor соответственно в качестве примитивов, вообще без явного сопоставления с образцом, - это класс вычислений, которые могут таким образом, будет выражаться строго большим для того или иного набора используемых примитивов. Теперь на этот можно дать содержательный ответ.

Однако функции непрозрачны. В любом случае сопоставление с образцом отсутствует. Без ограничения того, что мы можем использовать, вопрос снова теряет смысл. Тогда ограничение становится явным использованием именованных аргументов, точечным стилем программирования, так что мы позволяем себе кодировать только в комбинаторном стиле.

Итак, для списков, содержащих только fmap и app (<*>), мы можем выразить так много вычислений, и добавление join в наш арсенал действительно увеличивает его. Не так с функциями. join = W = CSI = flip app id. Конец.

Реализовав app f g x = (f x) (g x) = id (f x) (g x) :: (->) r (a->b) -> (->) r a -> (->) r b, у меня уже есть flip app id :: (->) r (r->b) -> (->) r b, с таким же успехом я мог бы назвать его join, так как тип подходит. Он уже существует, написал я это или нет. С другой стороны, от app fs xs :: [] (a->b) -> [] a -> [] b я не могу получить [] ([] b) -> [] b. Оба -> в (->) r (a->b) одинаковы; функции являются специальными.

(Кстати, в настоящий момент я не понимаю, как кодировать app явно списков, не выполняя фактического кодирования join. Использование понимания списков эквивалентно использованию concat; и concat не реализация join, это join).

join f = f <*> id

достаточно просто, так что нет никаких сомнений.

(edit: ну видимо еще были сомнения).

(=<<) = (<*>) . flip для функций. Это оно. это означает, что для функций Monad и Applicative Functor одинаковы. flip - это универсальный комбинатор. concat нет. Конечно, здесь есть определенное смешение с функциями. Но там нет конкретной функции управления функциями (например, concat - это конкретная функция управления списками) или где-либо еще, потому что функции непрозрачны.

Рассматриваемый как особый тип данных, он может подвергаться сопоставлению с образцом. Хотя как Монада она знает только о >>= и return. concat действительно использует сопоставление с образцом для выполнения своей работы. id нет.

id здесь сродни спискам [], а не concat. То, что это работает, означает, что функции, рассматриваемые как Applicative Functor или Monad, одинаковы. Конечно, в целом у Monad больше возможностей, чем у Applicative, но вопрос не в этом. Если бы вы могли выразить join для списков с <*> и [], я бы сказал, что это означало бы, что они имеют одинаковую силу и для списков.

В (=<<) = (<*>) . flip и flip, и (.) ничего не делают для функций, к которым они применяются. Таким образом, они ничего не знают о внутреннем устройстве этих функций. Например, foo = foldr (\x acc -> x+1) 0 правильно вычислит длину списка аргументов, если этот список был, например, [1,2]. Говоря this, опираясь на this, использует некоторые внутренние знания функции foo (то же самое, что и concat, используя внутреннее знание своих списков аргументов, через сопоставление с образцом). Но просто использовать базовые комбинаторы, такие как flip, (.) и т. Д., Нельзя.