I just added a Cofunctor instance for type composition, but there are two competing choices:
-- | Often useful for \"acceptors\" (consumers, sinks) of values.
class Cofunctor acc where
cofmap :: (a
-> b) -> (acc b ->
acc a)
-- | Composition of type constructors: unary & unary. Called "g . f"
-- in [1], section 5.
newtype (g :
.: f) a = T_T { runT_T :: g (f a)
}
instance (
Functor g, Cofunctor f) => Cofunctor (g :
.: f) where
cofmap h (T_T gf
) = T_T (fmap (
cofmap h) gf)
-- Or this alternative. Having both yields "Duplicate instance
-- declarations". How to decide between these instances?
-- instance (Cofunctor g, Functor f) => Cofunctor (g :.: f) where
-- cofmap h (T_T gf) = T_T (cofmap (fmap h) gf)
Any comments/suggestions about how or whether to make the choice between these two instances?
- Conal
On 3/12/07,
Conal Elliott <conal@conal.net> wrote:
I'm still interested in comments composition operators at http://haskell.org/haskellwiki/TypeComposition
. Now I see that my ":.::" is what [1] calls "StaticArrow".
Mainly, I'd like to hear thoughts on how to make an arrow out of a functor & arrow, with the functor on the inside. My attempt is called "
::.:" on the wiki page.
newtype ((
~>) ::.: f) a b = TT_T {
runTT_T :: f a ~> f b }
As mentioned in the comments, my Arrow definition isn't really satisfactory. Is there an arrow that corresponds to this sort of composition?
Thanks, - Conal