Zrozumienie, jak Jest to instancja Functor'a

Question

W wolnym czasie uczę się Haskella, więc jest to pytanie początkujące.

W moich odczytów natknąłem przykład ilustrujący jak Either a jest wystąpienie Functor:

instance Functor (Either a) where 
    fmap f (Right x) = Right (f x) 
    fmap f (Left x) = Left x 

Teraz staram się zrozumieć, dlaczego mapy wdrożeniowe w przypadku konstruktora Right wartości, ale nie w przypadku Left?

Oto moje rozumienie:

pierwsze chciałbym przepisać powyższy przypadek jako

instance Functor (Either a) where 
    fmap g (Right x) = Right (g x) 
    fmap g (Left x) = Left x 

now:

1. wiem, że fmap :: (c -> d) -> f c -> f d

2. jeśli podstawimy f z Either a otrzymujemy fmap :: (c -> d) -> Either a c -> Either a d

3. rodzaj Right (g x) jest Either a (g x) i rodzaj g x jest d, tak mamy, że rodzaj Right (g x) jest Either a d, czyli czego oczekujemy od fmap (patrz punkt 2 powyżej)

4. teraz, jeśli spojrzymy na Left (g x) możemy zastosować to samo rozumowanie, aby powiedzieć, że jego typ jest Either (g x) b, czyli Either d b, co nie jest, czego oczekujemy od fmap (patrz punkt 2 powyżej): the d powinien być drugi parametr nie pierwszy! Więc nie możemy mapować ponad Left.

Czy moje rozumowanie jest prawidłowe?

Answer 1

To prawda. Istnieje również inny, dość ważny powód takiego zachowania: Można pomyśleć o Either a b jako obliczeniu, które może się powieść i zwrócić b lub nie powieść się z komunikatem o błędzie a. (Jest to również sposób działania monady). Naturalne jest więc, że instancja funktora nie będzie dotykała wartości Left, ponieważ chcesz odwzorować obliczenia, jeśli się nie powiedzie, nie ma nic do manipulowania.

Answer 2

Twoje konto ma oczywiście rację. Może powodem, dla którego mamy problemy z takimi instancjami, jest to, że definiujemy nieskończenie wiele instancji funktora na raz - jeden na każdy możliwy typ Left. Ale instancja Functor to systematyczny sposób działania na nieskończenie wielu typach w systemie. Tak więc definiujemy nieskończenie wiele sposobów systematycznego działania na nieskończenie wielu typach w systemie. Instancja obejmuje ogólność na dwa sposoby.

Jeśli jednak weźmiesz to etapami, może nie jest tak dziwnie.Pierwszy z tych typów jest rozwlekłości wersja Maybe pomocą typ jednostki () i jego jedynym uprawnionym wartość ():

data MightBe b  = Nope() | Yep b 
data UnlessError b = Bad String | Good b 
data ElseInt b  = Else Int | Value b 

Tutaj możemy znudzi i zrobić abstrakcję:

data Unless a b = Mere a  | Genuine b 

Teraz robimy Nasze przypadki funktora, bezproblemowy, pierwszy patrząc dużo jak na przykład dla Maybe:

instance Functor MightBe where 
    fmap f (Nope()) = Nope() -- compare with Nothing 
    fmap f (Yep x) = Yep (f x) -- compare with Just (f x) 

instance Functor UnlessError where 
    fmap f (Bad str) = Bad str -- a more informative Nothing 
    fmap f (Good x) = Good (f x) 

instance Functor ElseInt where 
    fmap f (Else n) = Else n 
    fmap f (Value b) = Value (f b) 

Ale znowu, po co się męczyć, zróbmy abstrakcję:

instance Functor (Unless a) where 
    fmap f (Mere a) = Mere a 
    fmap f (Genuine x) = Genuine (f x) 

W Mere a warunki nie są dotykane, jak (), String i Int wartości nie były dotykane.

Answer 3

Teraz staram się zrozumieć, dlaczego mapy wdrożeniowe w przypadku konstruktora wartości rację, ale nie w przypadku lewicy?

Podłącz tutaj i może to mieć sens.

Założenie a = Ciąg (komunikat o błędzie) Stosuje się albo do pływaka.

Masz więc f: Float -> Integer mówi na przykład zaokrąglanie.

(Either String) (Float) = Float String.

teraz (fmap f) :: Albo String Float -> Albo String Int Więc co zrobisz z f? f nie ma pojęcia, co zrobić ze strunami, więc nie możesz tam nic zrobić. To jest oczywiście jedyną rzeczą, na którą możesz działać są prawidłowe wartości, pozostawiając niezmienione lewe wartości.

Innymi słowy Albo to funktor bo jest taka oczywista FMap dana przez:

• dla wartości Right stosuje f
• do wartości lewicowych zrobić nic

Answer 4

Jak inni wspomniano , Either type jest funktorem w obu argumentach. Ale w Haskell jesteśmy w stanie (bezpośrednio) zdefiniować tylko funktory w ostatnich argumentach typu. W takich przypadkach możemy obejść ograniczenia za pomocą newtype s:

newtype FlipEither b a = FlipEither { unFlipEither :: Either a b } 

Więc mamy konstruktora FlipEither :: Either a b -> FlipEither b a że otacza się Either do naszych newtype z zamienionych argumentów typu. I mamy dectructor unFlipEither :: FlipEither b a -> Either a b, który odwija ​​go z powrotem.Teraz możemy zdefiniować wystąpienie funktora w FlipEither „ostatni argument s, co jest rzeczywiście Either” s pierwszy argument:

instance Functor (FlipEither b) where 
    fmap f (FlipEither (Left x)) = FlipEither (Left (f x)) 
    fmap f (FlipEither (Right x)) = FlipEither (Right x) 

Zauważ, że jeśli zapominamy FlipEither przez chwilę możemy uzyskać tylko definicję Functor dla Either, po prostu z zamienioną na Left/Right. A teraz, gdy potrzebujemy instancji Functor w pierwszym argumencie typu Either, możemy zawinąć tę wartość do FlipEither i rozwinąć ją później. Na przykład:

fmapE2 :: (a -> b) -> Either a c -> Either b c 
fmapE2 f = unFlipEither . fmap f . FlipEither 

---

Aktualizacja: Zapraszamy do obejrzenia Data.Bifunctor, którego Either i (,) są instancjami. Każdy bifunctor ma dwa argumenty i jest funktorem w każdym z nich. Znajduje to odzwierciedlenie w metodach Bifunctor 's, first i second.

Definicja Bifunctor z Either bardzo symetryczne:

instance Bifunctor Either where 
    bimap f _ (Left a) = Left (f a) 
    bimap _ g (Right b) = Right (g b) 

    first f = bimap f id 

    second f = bimap id f