Add copy operations

[treeowl]

These are the FreeT editions of a generalization of streaming:Streaming.Prelude.copy.

copy :: (Applicative m, Comonad f) => FreeT f m r -> FreeT f (FreeT f m) r
copy' :: (Applicative m, Extend f) => FreeT f m r -> FreeT f (FreeT f m) r

Cale Gibbard suspects copy might make some sensible comonadish thing along with

extrude :: (Monad m, Comonad f) => FreeT f m r -> m r
extrude = iterT extract

[treeowl]

We can also take extend as an argument, as @ocharles suggested for the streaming version I proposed:

copygen :: (Applicative m, Functor f)
        => (forall a b. (f a -> b) -> f a -> g b)
        -> FreeT f m r -> FreeT f (FreeT g m) r
copygen g (FreeT t) = FreeT $ FreeT $ flip fmap t $
  \str -> case str of
    Pure r -> Pure (Pure r)
    Free f -> Free $ g (FreeT . pure . Pure . Free) (fmap (copygen g) f)

Note that this version allows the caller to change the inner functor.

[treeowl]

Even better:

copygen :: (Applicative m, Functor g)
        => (forall a b. (f a -> b) -> g a -> h b)
        -> FreeT g m r -> FreeT f (FreeT h m) r
copygen g (FreeT t) = FreeT $ FreeT $ flip fmap t $
  \str -> case str of
    Pure r -> Pure (Pure r)
    Free f -> Free $ g (FreeT . pure . Pure . Free) (fmap (copygen g) f)

[treeowl]

The Applicative constraint is a bit annoying. The presence of <*>, which we don't even use, greatly weakens the explanatory power of the type signature. I believe that if we could reasonably use Pointed instead, then the behavior would be fully determined. It would at least be obvious that no effects are duplicated. I wonder if there's a nice way to avoid that.

[treeowl]

Aha! I may have found part of a way. If we write

expound :: (Functor m, Functor g)
        => (forall a b. (m (f a) -> b) -> g a -> h b)
        -> FreeT g m r -> FreeT f (FreeT h m) r

which is not hard, then it's possible to define copygen in terms of it with the sole addition of pure. But it has an extra fmap.... I'll keep thinking on it.