функции как аппликативные функторы (Haskell / LYAH)

Прежде всего, запомните, как fmap определяется для аппликативов:

fmap f x = pure f <*> x

Это означает, что ваш пример такой же, как (fmap (+ 5) (* 3)) 4. Функция fmap для функций - это просто композиция, поэтому ваше точное выражение такое же, как ((+ 5) . (* 3)) 4.

Теперь давайте подумаем, почему экземпляр написан именно так. По сути, <*> применяет функцию в функторе к значению в функторе. Специализируясь на (->) r, это означает, что он применяет функцию, возвращаемую функцией из r, к значению, возвращаемому функцией из r. Функция, возвращающая функцию, - это просто функция двух аргументов. Итак, настоящий вопрос заключается в следующем: как бы вы применили функцию двух аргументов (r и a, возвращающую b) к значению a, возвращаемому функцией из r?

Первое, что следует отметить, это то, что вы должны вернуть значение типа (->) r, что означает, что результатом также должна быть функция из r. Для справки вот функция <*>:

f <*> g = \x -> f x (g x)

Поскольку мы хотим вернуть функцию, принимающую значение типа r, x :: r. Возвращаемая функция должна иметь тип r -> b. Как мы можем получить значение типа b? Итак, у нас есть функция f :: r -> a -> b. Поскольку r будет аргументом функции результата, мы получаем его бесплатно. Итак, теперь у нас есть функция из a -> b. Итак, пока у нас есть какое-то значение типа a, мы можем получить значение типа b. Но как получить значение типа a? Что ж, у нас есть еще одна функция g :: r -> a. Итак, мы можем взять наше значение типа r (параметр x) и использовать его для получения значения типа a.

Итак, окончательная идея проста: мы используем параметр, чтобы сначала получить значение типа a, вставив его в g. Параметр имеет тип r, g имеет тип r -> a, поэтому у нас есть a. Затем мы вставляем параметр и новое значение в f. Нам нужны оба, потому что f имеет тип r -> a -> b. Как только мы подключим и r, и a, у нас будет b1. Поскольку параметр находится в лямбда-выражении, результат имеет тип r -> b, что нам и нужно.

Просматривая ваш исходный вопрос, я думаю, что есть один тонкий, но очень важный момент, который вы могли упустить. Используя оригинальный пример от LYAH:

(+) <$> (+3) <*> (*100) $ 5

Это то же самое, что:

pure (+) <*> (+3) <*> (*100) $ 5

Ключевым моментом здесь является pure перед (+), который имеет эффект бокса (+) как аппликативного. Если вы посмотрите, как определяется pure, вы увидите, что для его распаковки вам нужно предоставить дополнительный аргумент, который может быть любым. Применяя <*> к (+) <$> (+3), получаем

\x -> (pure (+)) x ((+3) x)

Обратите внимание, что в (pure (+)) x мы применяем x к pure для распаковки (+). Итак, теперь у нас есть

\x -> (+) ((+3) x)

Добавляя (*100), чтобы получить (+) <$> (+3) <*> (*100) и снова применять <*>, мы получаем

\y -> (\x -> (+) ((+3) x)) y ((*100) y) {Since f <*> g = f x (g x)}

5  -> (\x -> (+) ((+3) x)) 5 ((*100) 5)

(\x -> (+) ((+3) x)) 5 (500)

5 -> (+) ((+3) 5) (500)

(+) 8 500

508

Итак, в заключение, x после f НЕ является первым аргументом нашего бинарного оператора, он используется для UNBOX оператора внутри pure.

В данном случае замена ((->)r) на f: r->(a->b)->(r->a)->(r->b)

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

Prelude Control.Applicative> (:) <*> (\x -> [x]) $ 2
[2,2]

Как понять Function as Functor и Function as Applicative?

Во-первых, как понимать функцию как функтор?

Мы можем рассматривать функтор как пустое поле, например:

instance Functor Maybe where 
    fmap :: (a -> b) -> f a -> f b
    fmap f (Just x) = Just (f x) 
    fmap f Nothing = Nothing

там Maybe тип можно увидеть как пустое поле с одним слотом, которое принимает тип для создания конкретного типа Maybe a. В функции fmap:

• Первый параметр - это функция, которая отображает от a до b;
• Второй параметр - это значение типа с заполненным слотом (конкретный тип), этот конкретный тип создается конструктором типа и имеет тип fa (f равно Maybe, поэтому fa равно Maybe a).

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

instance Functor ((->) r) where 
    fmap f g = (\x -> f (g x))

Так же, как функция fmap в Maybe Functor, мы должны рассматривать второй параметр g как значение конкретного типа, который генерируется с помощью f (f < / em> равно (->) r), поэтому fa равно (->) r a, что можно увидеть как r -> a. Наконец, нетрудно понять, что g x в функции fmap нельзя рассматривать как r -> x, это просто приложение-функция, которое можно рассматривать как (r -> a) x, также (x -> a).

<*> :: f (a -> b) -> f a -> f b
<*> :: (r -> a -> b) -> (r -> a) -> (r -> b)
<&> :: (a -> b) -> (r -> a) -> (r -> b)
f <*> g = \r -> f r (g r)

((+) <*> (+3)) 5

f <*> g = \r -> f r (g r)

pure (+) <*> (+3) = 
    \r -> f r (gr) =
    \r -> + (gr) =
    \r -> + (r + 3) =
    \r x -> x + (r + 3)

pure (+) <*> (+3) <*> (*100) = 
    \r -> f r (gr) =
    \r -> (r + 3) + (gr)
    \r -> (r + 3) + (r * 100)

(5 + 3) + (5 * 100) = 508 

(\x y z -> [x,y,z]) <$> (+3) <*> (*2) <*> (/2) $ 5 = [8.0,10.0,2.5]