How can fmap be used with a data constructor?

Question

I am trying to understand some haskell code.

It makes sense.

Prelude> fmap (+1) (Just 1)
Just 2

It also makes sense.

Prelude> (fmap.fmap) (+1) (Just [1])
Just [2]

But I do not understand how this works.

Prelude> (fmap.fmap) (+1) Just 1
Just 2

I tried to work with the details. It seems to me that this is what is happening.

(fmap (fmap (+1)) Just) 1

I tried to introduce subexpressions.

It makes sense.

Prelude> :t fmap (+1)
fmap (+1) :: (Functor f, Num b) => f b -> f b

That still makes sense.

Prelude> :t fmap (fmap (+1))
fmap (fmap (+1)) :: (Functor f, Functor f1, Num b) =>
    f (f1 b) -> f (f1 b)

But I don’t get it.

Prelude> :t fmap (fmap (+1)) Just
fmap (fmap (+1)) Just :: Num b => b -> Maybe b

How a function with type appeared

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

after application Just, which is of type:

a -> Maybe a

lead to this type?

Num b => b -> Maybe b

The question got confused in the function as a functor instance in haskell , maybe something has to do with it, but I'm still confused.

Answer 1

Just 1 (Just 1), . , :

   (fmap . fmap) (+1) Just 1
-> (\x -> fmap (fmap x)) (+1) Just 1
-> ((fmap (fmap (+1)) Just) 1

, :

fmap1 :: Functor f => (a -> b) -> f a -> f b
fmap2 :: Functor g => (c -> d) -> g c -> g d
(+1) :: Num h => h -> h
Just :: i -> Maybe i
1 :: Num j => j

fmapi - i- fmap ( ). , , , , fmap (+1), , c ~ d ~ h:

fmap1 :: Functor f => (a -> b) -> f a -> f b
fmap2 :: Functor g => (h -> h) -> g h -> g h
(+1) :: Num h => h -> h
Just :: i -> Maybe i
1 :: Num j => j

, fmap (fmap1) fmap (+1) :: Functor g => g h -> g h , Just :: i -> Maybe i - . , , : (a -> b) ~ g h -> g h, a ~ b ~ g h, , f (g h) ~ i -> Maybe i, , f (g h) ~ (->) i (Maybe i) so f ~ (->) i g ~ Maybe, h ~ i, i ~ j > :

fmap1 :: (Maybe i -> Maybe i) -> (->) i (Maybe i) -> (->) i Maybe i
fmap2 :: (i -> i) -> Maybe i -> Maybe i
(+1) :: Num h => i -> i
Just :: i -> Maybe i
1 :: Num i => i

, (->) r , , base-4.10.1.0 :

instance Functor ((->) r) where
    fmap = (.)

, fmap, " " . , Just fmap (+1). , fmap (.), - fmap Maybe, :

   ((fmap (fmap (+1)) Just) 1
-> (((.) (fmap (+1)) Just) 1
-> ((\x -> (fmap (+1) (Just x)) 1
-> fmap (+1) (Just 1)
-> Just 2

, (fmap (+1)) - Just 1.

Answer 2

, , f (->) a f1 Maybe,

Just :: (->) a (Maybe a)

, fmap (fmap (+1)) , :

fmap (fmap (+1)) :: Num b => (->) a (Maybe b) -> (->) a (Maybe b)

(->) , :

fmap (fmap (+1)) :: Num b => (a -> Maybe b) -> (a -> Maybe b)

Just :: a -> Maybe a,

fmap (fmap (+1)) Just :: Num a => a -> Maybe a