`（fmap。fmap）sumの型はちょうど[1、2、3]`が働くのはなぜですか？

Question

私は素晴らしいHaskell Programming from first principlesを読んで私の人生の時間を持っていると私は私がちょうど離れ（ページ1286電子書籍リーダーを）取ることができないんだけど、次の例で来た：それは明らかである

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

私にはどのように次のような作品：

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

そして、私はすでに手動タイプがどのように機能するかを理解するために(fmap . fmap)を解体。しかし、これを「2倍にする」と考えると、JustとListの両方のデータコンストラクタを取り上げているので意味がありません。

私はghciに次のように出て型付け：

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を渡すとき、とfの両方をMaybeに置き換えることをコンパイラはどのように知っていますか？私はここで良い答えを得た後、どうやって自分自身を分かったのだろうか？しかし、関数型(->)とMaybe上、（そのタイプの問題を有している(fmap . fmap) sum (Just [1,2,3])であろう）MaybeとList両方にわたって持ち上げていない

Answer 1

特定の回答の仕組みがわからない場合は、前の手順の種類で指定した引数を並べます。

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]) 

それはここに、その者の代わりにRHSを試してみましょうべきfかf1明らかではありません。私たちは、カンニングと(fmap . fmap) sum Justの実際の値がどうあるべきかをチェックするためにGHCiのを頼むことができます。

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]が有効なファンクタです。

Answer 2

。

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]