All geek questions in one place

Why are types executed in `(fmap. Fmap) sum Just [1, 2, 3]`?

I have time when I read the wonderful Haskell Programming from the first principles , and I came to the following example, m is simply not able to disperse (electronic reader):

Prelude> (fmap . fmap) sum Just [1, 2, 3]
Just 6

It’s obvious to me how the following works:

Prelude> fmap sum $ Just [1,2,3]
Just 6

And I already manually deconstructed (fmap . fmap)to understand how these types work. But, thinking of it as "raising twice", this makes no sense, as I am raising Just and List as data constructors.

I introduced the ghcifollowing:

Prelude> :t (fmap . fmap)
(fmap . fmap)
  :: (Functor f, Functor f1) => (a -> b) -> f1 (f a) -> f1 (f b)

Prelude> :t (fmap . fmap) sum
(fmap . fmap) sum
  :: (Num b, Foldable t, Functor f, Functor f1) =>
     f1 (f (t b)) -> f1 (f b)

Prelude> :t (fmap . fmap) sum Just
(fmap . fmap) sum Just :: (Num b, Foldable t) => t b -> Maybe b

, . (fmap . fmap) sum Just: , f1 f Maybe? , , ?

+4
2

, , , .

Prelude> :t (fmap . fmap) sum
(fmap . fmap) sum
  :: (Functor f, Functor f1, Num b) => f (f1 [b]) -> f (f1 b)

, Just f (f1 [b]), (fmap . fmap) sum Just f (f1 b).

Just :: (Functor f, Functor f1, Num b) => f (f1 [b])

, f f1, RHS. GHCi , (fmap . fmap) sum Just:

Prelude> :t (fmap . fmap) sum Just
(fmap . fmap) sum Just :: Num b => [b] -> Maybe b

:

(Functor f, Functor f1, Num b) => f (f1 b)

, f f1 . , (, -> ):

(fmap . fmap) sum Just :: Num b => [b] -> Maybe b
-- Same as...
(fmap . fmap) sum Just :: Num b => (->) [b] (Maybe b)
-- Or...
(fmap . fmap) sum Just :: Num b => ((->) [b]) (Maybe b)
--                     Functor f = ((->) [b])
--                                Functor f1 = Maybe

, , , Functor f (->) [b]... , ! Functor f1 - Maybe, .

:

Prelude> :t (fmap . fmap) sum :: Num b => ([b] -> Maybe [b]) -> ([b] -> Maybe b)
(fmap . fmap) sum :: Num b => ([b] -> Maybe [b]) -> ([b] -> Maybe b)
  :: Num b => ([b] -> Maybe [b]) -> [b] -> Maybe b

GHCi , .

, , , (->) [b] !

+6

Maybe, List ( (fmap . fmap) sum (Just [1,2,3]), ), (->) Maybe.

Just :: a -> Maybe a
     -- ((->) a) (Maybe a)
     -- f (g a)   for f ~ ((->) a)  and  g ~ Maybe

(fmap . fmap) :: (a   -> b) -> f (g a  ) -> f (g b)
     -- Num x => ([x] -> x) -> f (g [x]) -> f (g x)
     -- Num x => ([x] -> x) -> ([x] -> Maybe [x]) -> [x] -> Maybe x
     --          ^             ^                     ^
     --          sum           Just                  [1,2,3]
+6
source

Source: https://habr.com/ru/post/1690446/

More articles:


All Articles