Dans le tutoriel lets-lens, comment refactorisez-vous l'appel à traverser afin de le mettre en œuvre?

Question

En the exercises j'ai mis en œuvre fmapT:

-- Let's remind ourselves of Traversable, noting Foldable and Functor. 
-- 
-- class (Foldable t, Functor t) => Traversable t where 
-- traverse :: 
--  Applicative f => 
--  (a -> f b) 
--  -> t a 
--  -> f (t b) 

-- | Observe that @fmap@ can be recovered from @traverse@ using @Identity@. 
-- 
-- /Reminder:/ fmap :: Functor t => (a -> b) -> t a -> t b 
fmapT :: 
    Traversable t => 
    (a -> b) 
    -> t a 
    -> t b 
fmapT = 
    error "todo: fmapT" 

Maintenant, comment puis-je mettre over?

-- | Let's refactor out the call to @traverse@ as an argument to @fmapT@. 

over :: 
    ((a -> Identity b) -> s -> Identity t) 
    -> (a -> b) 
    -> s 
    -> t 
over = error "undefined" 

Answer 1

Vous pouvez mettre en œuvre à l'aide fmapTtraverse comme:

fmapT f s = runIdentity (traverse (Identity . f) s) 

maintenant le prochain exercice est de factoriser cette fonction en fournissant traverse comme paramètre plutôt que de coder en dur dans la définition. Si vous choisissez Identity comme constructeur de type applicatif alors le type de traverse est:

(Traversable t) => (a -> Identity b) -> t a -> Identity (t b) 

si vous fournissez cela comme un paramètre à fmapT vous vous retrouvez avec quelque chose comme over:

over' :: Traversable t => ((a -> Identity b) -> t a -> Identity (t b)) -> (a -> b) -> t a -> t b 
over' l f s = runIdentity (l (Identity . f) s) 

depuis le Traversable la contrainte existe dans traverse il n'est pas requis par over' qui a le type plus général de over donné dans l'exercice c'est-à-dire

over :: ((a -> Identity b) -> (s -> Identity t)) -> (a -> b) -> s -> t 

et

over' = over traverse