title: Are the "natural transformations" we apply on Coyoneda to get a Functor actually "natural transformations"?
body: <p>I have a theoretical question about the nature of a type that is used in
  a lot of examples explaining the Coyoneda lemma. They are usually referred to
  as "natural transformations" which to my knowledge mappings between functors.
  What puzzles me is that in these examples they sometimes map from <code>Set</code> to some functor <code>F</code>. So it does not really semm to be a mapping between functors but something a little more relaxed.</p>
  
  <p>Here is the code in question:</p>
  
  <pre><code>{-# LANGUAGE GADTs #-}
  {-# LANGUAGE RankNTypes #-}
  module Coyo where
  
  import           Data.Set (Set)
  import qualified Data.Set as Set
  
  data Coyoneda f a where
    Coyoneda :: (b -&gt; a) -&gt; f b -&gt; Coyoneda f a
  
  instance Functor (Coyoneda f) where
    fmap f (Coyoneda c fa) =  Coyoneda (f . c) fa
  
  set :: Set Int
  set = Set.fromList [1,2,3,4]
  
  lift :: f a -&gt; Coyoneda f a
  lift fa = Coyoneda id fa
  
  lower :: Functor f =&gt; Coyoneda f a -&gt; f a
  lower (Coyoneda f fa) = fmap f fa
  
  type NatT f g = forall a. f a -&gt; g a
  
  coyoset :: Coyoneda Set Int
  coyoset = fmap (+1) (lift set)
  
  applyNatT :: NatT f g -&gt; Coyoneda f a -&gt; Coyoneda g a
  applyNatT n (Coyoneda f fa) = Coyoneda f (n fa)
  
  -- Set.toList is used as a "natural transformation" here
  -- while it conforms to the type signature of NatT, it
  -- is not a mapping between functors `f` and `g` since
  -- `Set` is not a functor.
  run :: [Int]
  run = lower (applyNatT Set.toList coyoset)
  </code></pre>
  
  <p>What am I misunderstanding here?</p>
  
  <p><strong>EDIT:</strong> After a discussion on #haskell in freenode I think I need to clarify my question a little. It's basically: "What is <code>Set.toList</code> in a
  category theoretic sense? Since it is obviously(?) not a natural transformation".</p>