Haskell: Как <*> объявлен? [закрытый]

maybeAnd :: Maybe Bool -> Maybe Bool -> Maybe Bool
maybeAnd x y = do x' <- x
                  y' <- y
                  return (x' && y')

Теперь это много проблем, просто чтобы перевести простую функцию - вот почему Control.Monad предоставляет функцию, которая делает это автоматически, liftM2 . 2 в его названии указывает на то, что он работает с функциями ровно с двумя аргументами; аналогичные функции существуют для функций с 3, 4 и 5 аргументами. Эти функции лучше , но не идеальны, и указывать количество аргументов некрасиво и неуклюже.

Это подводит нас к статье , в которой был представлен класс типа Applicative .В нем авторы делают по существу два наблюдения:

• Преобразование функций с несколькими аргументами в Функтор - это очень естественная вещь
• . Для этого не требуются все возможности ] Monad

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

Все это подводит нас к следующему пункту: (<*>) просто представляет приложение функции -Так зачем произносить это слово иначе, чем вы произносите пробел «оператор сопоставления»?

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

ap :: (Monad m) => m (a -> b) -> m a -> m b

Где ap , конечно, сокращение от «применять». Поскольку любая монада может быть аппликативной , а ap нуждается только в подмножестве функций, присутствующих в последнем, мы, возможно, можем сказать, что if (<*>) не был оператором, он должен называться ap .

Мы также можем подойти к вещам с другой стороны. Операция подъема функтора называется fmap , потому что это обобщение операции map для списков. Какая функция для списков будет работать как (<*>) ? Конечно, есть то, что ap делает со списками, но само по себе это не особенно полезно.

На самом деле, для списков существует, пожалуй, более естественная интерпретация. Что приходит в голову, когда вы смотрите на следующую сигнатуру типа?

listApply :: [a -> b] -> [a] -> [b]

Есть что-то настолько заманчивое в идее выстраивать списки параллельно, применяя каждую функцию в первом к соответствующему элементу второго. К сожалению для нашего старого друга Монады , эта простая операция нарушает законы монад , если списки имеют разную длину.Но он налагает штраф Applicative , и в этом случае (<*>) становится способом связать вместе обобщенную версию zipWith , так что, возможно, мы можем представить себе, как назовем его fzipWith ?

Эта идея архивирования фактически завершает круг. Помните ту математику о моноидальных функторах? Как следует из названия, это способ объединения структуры моноидов и функторов, оба из которых являются знакомыми классами типов Haskell:

class Functor f where
    fmap :: (a -> b) -> f a -> f b

class Monoid a where
    mempty :: a
    mappend :: a -> a -> a

Как бы они выглядели, если бы вы поместили их в коробку вместе и немного встряхнули? Из Functor мы сохраним идею структуры независимо от ее параметра типа , а из Monoid мы сохраним общую форму функций:

class (Functor f) => MonoidalFunctor f where
    mfEmpty :: f ?
    mfAppend :: f ? -> f ? -> f ?

Мы не хотим предполагать, что существует способ создать действительно «пустой» Функтор , и мы не можем вызвать значение произвольного типа, поэтому мы исправим тип mfEmpty как f () .

Мы также не хотим, чтобы mfAppend требовал согласованного параметра типа, поэтому теперь у нас есть следующее:

class (Functor f) => MonoidalFunctor f where
    mfEmpty :: f ()
    mfAppend :: f a -> f b -> f ?

Какой тип результата для mfAppend ? У нас есть два произвольных типа, о которых мы ничего не знаем, поэтому у нас не так много вариантов.Наиболее разумно просто сохранить оба:

class (Functor f) => MonoidalFunctor f where
    mfEmpty :: f ()
    mfAppend :: f a -> f b -> f (a, b)

В этот момент mfAppend теперь явно является обобщенной версией zip в списках, и мы можем восстановить Applicative ] легко:

mfPure x = fmap (\() -> x) mfEmpty
mfApply f x = fmap (\(f, x) -> f x) (mfAppend f x)

Это также показывает нам, что pure связан с элементом идентичности Моноида , поэтому другими хорошими названиями для него могут быть любые, предполагающие значение единицы, нуль операция или что-то в этом роде.

Это было много, поэтому подведем итог:

• (<*>) - это просто модифицированное приложение-функция, поэтому вы можете прочитать его как «ap» или «применить», или полностью исключить его. вы бы нормальное приложение функции.
• (<*>) также примерно обобщает zipWith в списках, поэтому вы можете читать его как «zip-функторы с», аналогично чтению fmap как «map a функтор с ".

Первый ближе к назначению класса типа Applicative - как следует из названия - так что я рекомендую именно это.

На самом деле, я рекомендую либеральное использование без произношения всех расширенных операторов приложения :

• (<$>) , которые переводят функцию с одним аргументом в Функтор
• (<*>) , который связывает функцию с несколькими аргументами через Applicative
• (= <<) , который связывает функцию, входящую в Монада на существующее вычисление

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