Różnica w zdolnościach między fmap i bind?

Question

Jestem nowicjuszem w zakresie programowania funkcjonalnego (pochodzącego z javascript) i ciężko mi jest odróżnić te dwie rzeczy, co jest również męczące z moim rozumieniem funktorów kontra monad.

funktora:

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

Monada (uproszczonych)

class Monad m where 
    (>>=) :: m a -> (a -> m b) -> m b 

• fmap wykonuje funkcję i funktora i zwraca funktor.
• >>= przyjmuje funkcję i monadę i zwraca monadę.

Różnica między nimi polega na parametr funkcyjny:

• fmap - (a -> b)
• >>= - (a -> m b)

>>= przyjmuje parametr funkcyjny zwraca monadę. Wiem, że to jest znaczące, ale mam trudności z zobaczeniem, jak ta jedna drobna rzecz sprawia, że ​​monady są znacznie potężniejsze niż funktory. Czy ktoś może wyjaśnić?

Answer 1

No (<$>) jest aliasem dla fmap i jest taka sama jak (>>=) z argumentami zamienionych:

(<$>) :: (x -> y) -> b x -> b y 
(=<<) :: (x -> b y) -> b x -> b y 

Różnica jest dość oczywiste: z funkcją wiązania, możemy zastosować funkcję zwracającą a b y zamiast y. Więc co to za różnica?

Rozważmy ten mały przykład:

foo <$> Just 3 

Uwaga, (<$>) będzie stosowana foo do 3 i umieścić wynik z powrotem do Just. Innymi słowy, wynik tego obliczenia nie może być być . Wręcz przeciwnie:

bar =<< Just 3 

To obliczenie może powrócić Nothing. (Na przykład, bar x = Nothing to zrobi.)

Możemy zrobić coś podobnego z listy monady:

foo <$> [Red, Yellow, Blue] -- Result is guaranteed to be a 3-element list. 
bar =<< [Red, Yellow, Blue] -- Result can be ANY size. 

w skrócie, z (<$>) (tj fmap), „struktury” w wyniku jest zawsze identyczne z danymi wejściowymi.Ale z (tj. (>>=)) struktura wyniku może się zmienić. Pozwala to na warunkowe wykonywanie, reagowanie na dane wejściowe i całą masę innych rzeczy.

Answer 2

Krótka odpowiedź brzmi: jeśli możesz zmienić m (m a) w m a w sensie, który ma sens, to jest Monada. Jest to możliwe dla wszystkich Monad, ale niekoniecznie dla Funktorów.

Myślę, że najbardziej mylące jest to, że wszystkie popularne przykłady Funktorów (np. List, Maybe, IO) to także Monady. Potrzebujemy przykładu czegoś, co jest Funktorem, ale nie Monadą.

Użyję przykładu z hipotetycznego programu kalendarza. Poniższy kod definiuje funkcję Event Functor, która przechowuje dane związane ze zdarzeniem i czasem jego wystąpienia.

import Data.Time.LocalTime 

data Event a = MkEvent LocalTime a 

instance Functor Event where 
    fmap f (MkEvent time a) = MkEvent time (f a) 

W Event obiektów zapamiętuje czas, który występuje zdarzenie i jakieś dodatkowe informacje, które mogą być zmienione za pomocą fmap. Teraz spróbujmy i sprawiają, że monady:

instance Monad Event where 
    (>>=) (MkEvent timeA a) f = let (MkEvent timeB b) = f a in 
           MkEvent <notSureWhatToPutHere> b 

stwierdzamy, że nie możemy, bo skończy się z dwóch LocalTime obiektów. timeA z podanego i timeB z Event podanego przez wynik f a. Nasz typ Event jest zdefiniowany jako mający tylko jeden LocalTime (time), w którym występuje i dlatego uczynienie z niego Monady nie jest możliwe bez zamieniania dwóch na LocalTime s w jeden. (Może się zdarzyć, że może to mieć sens, więc jeśli naprawdę chcesz, możesz zamienić to w monadę).

Answer 3

Załóżmy na chwilę, że IO były tylko Functor, a nie Monad. Jak możemy uporządkować dwie akcje? Powiedz, tak jak getChar :: IO Char i putChar :: Char -> IO().

Możemy spróbować mapować ponad getChar (działanie, które po uruchomieniu odczytuje Char ze standardowego wejścia) przy użyciu putChar.

fmap putChar getChar :: IO (IO()) 

Teraz mamy program, który po uruchomieniu, odczytuje Char ze standardowego wejścia i tworzy program, który po uruchomieniu, pisze Char na standardowe wyjście. Ale naprawdę chcemy programu, który po uruchomieniu czyta Char ze stdin i zapisuje Char na standardowe wyjście. Więc potrzebujemy „spłaszczenie” (w przypadku IO „sekwencjonowanie”) z funkcji typu:

join :: IO (IO()) -> IO() 

Functor sama nie zapewnia tę funkcję. Ale to jest funkcją Monad, gdzie to ma bardziej ogólny typ:

join :: Monad m => m (m a) -> m a 

Co to wszystko ma wspólnego z >>=? Jak to się dzieje, monadycznego wiążą się właśnie kombinacja fmap i join:

:t \m f -> join (fmap f m) 
(Monad m) => m a1 -> (a1 -> m a) -> m a 

Innym sposobem widząc różnicy jest to, że fmap nigdy się nie zmienia ogólnej struktury odwzorowanym wartości, ale join (a więc >>= również) mogę to zrobić.

Pod względem IO działań fmap będzie nigdy przyczyną Ważne odczytuje/zapisuje lub inne efekty. Ale join sekwencyjnie odczytuje/zapisuje wewnętrzną akcję po akcji zewnętrznej.