以下类型的 Functor 实例是什么： newtype F2 xa = F2 ((a -> x) -> a)

Question

So I want to write the fmap function for the above mentioned type, but I am stuck here:

instance Functor (F2 x) where
 fmap :: (a -> b) -> (F2 x a) -> (F2 x b)
 fmap f (F2 g) = F2 ( f _ )

Answer 1

A good strategy here is to follow the types. GHC can help us along the way if we write incomplete definitions with typed holes :

newtype F2 x a = F2 ((a -> x) -> a)

instance Functor (F2 x) where
    fmap f (F2 g) = _

If we try to compile this, GHC reports back:

Diatonic.hs:275:21: error:
    • Found hole: _ :: F2 x b
      Where: ‘b’ is a rigid type variable bound by
               the type signature for:
                 fmap :: forall a b. (a -> b) -> F2 x a -> F2 x b
               at Diatonic.hs:275:5-8
             ‘x’ is a rigid type variable bound by
               the instance declaration
               at Diatonic.hs:274:10-23
    • In the expression: _
      In an equation for ‘fmap’: fmap f (F2 g) = _
      In the instance declaration for ‘Functor (F2 x)’
    • Relevant bindings include
        g :: (a -> x) -> a (bound at Diatonic.hs:275:16)
        f :: a -> b (bound at Diatonic.hs:275:10)
        fmap :: (a -> b) -> F2 x a -> F2 x b (bound at Diatonic.hs:275:5)
    |
275 |     fmap f (F2 g) = _
    |                 

This means we have to fill the hole with an F2 xb value. The only way we have of creating one is by using the constructor (for the following steps, I will omit the unchanging boilerplate):

fmap f (F2 g) = F2 _

• Found hole: _ :: (b -> x) -> b

So we need a function that takes a b -> x . We can set up one. Let's call its argument k , and see if we can complete its body:

fmap f (F2 g) = F2 (\k -> _)

• Found hole: _ :: b

The only thing that can produce a b is f:: a -> b :

fmap f (F2 g) = F2 (\k -> f _)

• Found hole: _ :: a

The only thing that can produce an a is g:: (a -> x) -> a :

fmap f (F2 g) = F2 (\k -> f (g _))

• Found hole: _ :: a -> x

We are supposed to provide an a -> x function, so let's throw in another lambda (for a possible shortcut, see the final part of the answer):

fmap f (F2 g) = F2 (\k -> f (g (\a -> _)))

• Found hole: _ :: x

The only thing that can produce a x is k:: b -> x

fmap f (F2 g) = F2 (\k -> f (g (\a -> k _)))

• Found hole: _ :: b

The only thing that can produce a b still is f:: a -> b :

fmap f (F2 g) = F2 (\k -> f (g (\a -> k (f _))))

• Found hole: _ :: a

If we try to use g to create an a value like we did several steps ago, we will get trapped in a vicious circle. However, we don't have to do that this time, as the a argument of the lambda is in scope:

fmap f (F2 g) = F2 (\k -> f (g (\a -> k (f a))))

And we are done.

(It is worth mentioning that your F2 is provided by transformers , where it is known as Select .)

The definition arguably looks a little tidier if we write \a -> k (fa) pointfree:

instance Functor (F2 x) where
    fmap f (F2 g) = F2 (\k -> f (g (k . f)))

We might have skipped directly from the a -> x hole to here by noticing our only viable option there was composing f:: a -> b and k:: b -> x .

Answer 2

You can make GHC do the hard work for you:

GHCi, version 8.8.2: https://www.haskell.org/ghc/  :? for help
Prelude> :set -ddump-deriv -dsuppress-all -XDeriveFunctor
Prelude> newtype F2 x a = F2 ((a -> x) -> a) deriving(Functor)

==================== Derived instances ====================
Derived class instances:
  instance Functor (F2 x) where
    fmap f_a1bk (F2 a1_a1bl)
      = F2
          ((\ b4_a1bm b5_a1bn
              -> f_a1bk
                   (b4_a1bm
                      ((\ b2_a1bo b3_a1bp
                          -> (\ b1_a1bq -> b1_a1bq) (b2_a1bo (f_a1bk b3_a1bp)))
                         b5_a1bn)))
             a1_a1bl)
    (<$) z_a1br (F2 a1_a1bs)
      = F2
          ((\ b6_a1bt b7_a1bu
              -> (\ b5_a1bv -> z_a1br)
                   (b6_a1bt
                      ((\ b3_a1bw b4_a1bx
                          -> (\ b2_a1by -> b2_a1by)
                               (b3_a1bw ((\ b1_a1bz -> z_a1br) b4_a1bx)))
                         b7_a1bu)))
             a1_a1bs)


Derived type family instances:


Prelude>

Rename GHC's weird names and remove its excessive indentation, and you end up with this:

instance Functor (F2 x) where
  fmap f (F2 a1) = F2 ((\b4 b5 -> f (b4 ((\b2 b3 -> (\b1 -> b1) (b2 (f b3))) b5))) a1)

Now we can do some simplification to make that more understandable. Let's look at this subexpression:

(\b2 b3 -> (\b1 -> b1) (b2 (f b3))) b5

(\b1 -> b1) is the identity function, which we can beta-reduce to get rid of:

(\b2 b3 -> b2 (f b3)) b5

Now we can beta-reduce again, this time b5 for b2 :

\b3 -> b5 (f b3)

This is now clearly equivalent to b5. f b5. f . Plug it back in:

instance Functor (F2 x) where
  fmap f (F2 a1) = F2 ((\b4 b5 -> f (b4 (b5 . f))) a1)

One more beta-reduction: a1 for b4 :

instance Functor (F2 x) where
  fmap f (F2 a1) = F2 (\b5 -> f (a1 (b5 . f)))

And we're done. No hard work on our part needed.