翻转函子实例 Haskell

Question

I need to write the Functor instances for the Flip datatype:

data K a b = K a
newtype Flip f a b = Flip (f b a) deriving (Eq, Show)

instance Functor (Flip K a) where
fmap=undefined

The solution I was given in class is:

instance Functor (Flip K a) where
    fmap f (Flip (K b)) = Flip (K (f b))

I really don't understand what's going on here and I'm beginning to doubt my whole understanding of data types and functors. What I do understand is this (please correct me if any of this is wrong):

• K is a data type that turns 2 parameters into a structure K a ( that only keeps the first parameter)
• Flip is a datatype that turns 3 arguments into a structure with one
• Because in fmap:: (a-> b) -> fa -> fb , fa has kind * , to write the Functor instance of Flip , we write it on the last type in Flip . Aka f and a are "constants" in a way, and we write the functor for the type b . I would write something like:

instance Functor (Flip f a) where
   fmap f (Flip x y z) = fmap Flip x y (f z)

I know that that is completely wrong but I'm not sure why.

Also, why would we bring K into the Functor instance of Flip? Can someone explain thoroughly the process of coming up with this solution and why it is correct?

Answer 1

• K is a data type that turns 2 parameters into a structure K a ( that only keeps the first parameter)

This isn't quite right. K ab is a data type formed using two parameters, but it's not really right to say that it "turns them into" anything. Instead, it's simply just stating to the world that there now exists a new type: K ab . "So what?" you might ask. Well, the second half of the data type defines how to make new values of this type. That part says, "You can make a new value of type K ab with this function I'll call K which has type a -> K ab ." It's really important to recognize that there is a distinction between the type K and the constructor K .

So, it's not that K "only keeps the first parameter"—it's that the constructor K (which is a function) happens to not take any arguments of type b .

---

• Flip is a datatype that turns 3 arguments into a structure with one

Just as above, this is not quite right. The Flip declaration states that there can be values of type Flip fab , and the only way to make them is by using the constructor Flip that has type fba -> Flip fab .

In case you're wondering how I'm coming up with the type signatures for the constructors K and Flip , it's not actually mysterious, and you can double check by typing :t K or :t Flip into GHCi. These types are assigned based entirely on the right hand side of the data type declaration. Also, note that the type name and constructor don't have to be the same . For instance, consider this data type:

data Foo a = Bar Int a | Foo String | Baz a a

This declares a type Foo a with three constructors:

Bar :: Int -> a -> Foo a
Foo :: String -> Foo a
Baz :: a -> a -> Foo a

Basically, each of the types after the constructor name are the arguments, in order, to the constructor.

---

• Because in fmap:: (a-> b) -> fa -> fb , fa has kind * , to write the Functor instance of Flip , we write it on the last type in Flip . Aka f and a are "constants" in a way, and we write the functor for the type b .

This is basically right! You could also say that f has kind * -> * . Since Flip has kind (* -> *) -> * -> * -> * , you need to provide it two type arguments (the first of kind * -> * and the second of kind * ) to get it to the right kind. Those first two arguments become fixed ("constants" in a way) in the instance.

---

I would write something like: ... I know that that is completely wrong but I'm not sure why.

The reason your instance is completely wrong is that you've mixed up the type with the constructor . It doesn't make sense to put (Flip xyz) in the pattern position where you did because the constructor Flip only takes one argument—remember, it's type is Flip:: fba -> Flip fab : So you'd want to write something like:

instance Functor (Flip f a) where
   fmap f (Flip fxa) = ...

Now, what do you fill in for the ... ? You have a value fxa:: fxa , and you have a function f:: x -> y , and you need to produce a value of type fya . Honestly, I don't know how to do that. After all, what is a value of typ fxa ? We don't know what f is?!

---

Also, why would we bring K into the Functor instance of Flip ? Can someone explain thoroughly the process of coming up with this solution and why it is correct?

We saw just above that we can't write the Functor instance for an arbitrary f , but what we can do is write it for a particular f . It turns out that K is just such a particular f that works. Let's try to make it work:

instance Functor (Flip K a) where
  fmap f (Flip kxa) = ...

When f was arbitrary, we got stuck here, but now we know that kxa:: K xa . Remember that the only way to make a value of type K xa is using the constructor K . Therefore, this value kxa must have been made using that constructor, so we can break it apart as in: kxa ⩳ K x' where x':: x . Let's go ahead and put that into our pattern:

  fmap f (Flip (K x')) = ...

Now we can make progress! We need to produce a value of type Flip K ay . Hmm. The only way to produce a value of type Flip is using the Flip constructor, so let's start with that:

  fmap f (Flip (K x')) = Flip ...

The Flip constructor at type Flip K ay takes a value of type K ya . The only way to produce one of those is with the K constructor, so let's add that:

  fmap f (Flip (K x')) = Flip (K ...)

The K constructor at type K ya takes a value of type y , so we need to provide a value of type y here. We have a value x':: x and a function f:: x -> y . Plugging the first into the second gives us the value we need:

  fmap f (Flip (K x')) = Flip (K (f x'))

Just rename x' to b , and you have exactly the code your teacher provided.

Answer 2

DDub wrote in their answer:

You have a value fxa:: fxa , and you have a function f:: x -> y , and you need to produce a value of type fya . Honestly, I don't know how to do that. After all, what is a value of type fxa ? We don't know what f is?!

And I agree, but I woulld like to add a bit. Your teacher's idea as to how to deal with this is pretty cool (things like this K come in quite handy when you are trying to write down some counterexample, like here ), and yet, I reckon we can make this code way broader. I use Data.Bifunctor .

So, what are Bifunctor s ? They are just what their name says: a * -> * -> * type (which we call bifunctors as well sometimes, yet they are not the same thing) which allows mapping over its both arguments (snippet from the source ):

class Bifunctor p where
  -- | Map over both arguments at the same time.
  --
  -- @'bimap' f g ≡ 'first' f '.' 'second' g@
  bimap :: (a -> b) -> (c -> d) -> p a c -> p b d
  bimap f g = first f . second g
  {-# INLINE bimap #-}

  -- | Map covariantly over the first argument.
  --
  -- @'first' f ≡ 'bimap' f 'id'@
  first :: (a -> b) -> p a c -> p b c
  first f = bimap f id
  {-# INLINE first #-}

  -- | Map covariantly over the second argument.
  --
  -- @'second' ≡ 'bimap' 'id'@
  second :: (b -> c) -> p a b -> p a c
  second = bimap id
  {-# INLINE second #-}

So, here is how I would go about that:

instance Bifunctor f => Functor (Flip f a) where
    fmap x2y (Flip fxa) = Flip (first x2y fxa)

Speaking of your teacher's code, it's a very nice idea, yet a more narrow one as K is a Bifunctor :

instance Bifunctor K where
    bimap f _g (K a) = K (f a)

A lawful one:

bimap id id (K a) = K (id a) = id (K a)

As it says in the link above , having bimap only written down, that's the only law we need to worry about.

Answer 3

We just need to use sane and helpful naming, and suddenly it all becomes simple and clear (as opposed to torturous and contorted):

data K b a = MkK b                     -- the type (K b a)      "is" just (b)
newtype Flip f a b = MkFlip (f b a)    -- the type (Flip f a b) "is" (f b a)
                     deriving (Eq, Show)

instance Functor (Flip K a) where
    -- fmap :: (b -> c) -> Flip K a b -> Flip K a c
    fmap g (MkFlip (MkK b)) = MkFlip (MkK (g b))
        --        MkK b :: K b a
        --  MkFlip (_ :: K b a) :: Flip K a b

There's not even one question arising in our minds now looking at this, not one doubt we aren't able to immediately resolve.

Using same names for types and for data constructors while teaching , as well as using f both for "f"unction and "f"unctor, is pure abuse of the students.

Only when you've become fed up with all the Mk s and don't feel they are helpful to you in any way, you can safely and easily throw them away, as experts usually do.