Is Alternative constraint needed for: Applicative (Cofree f)?

[Icelandjack]

This rules out deriving the Applicative instance for Moore machines

instance Applicative (Moore a) where
  pure a = r where r = Moore a (const r)

  Moore f ff <*> Moore a fa  = Moore (f a) (\i -> ff i <*> fa i)

So instead of implementing

instance Alternative f => Applicative (Cofree f) where
  pure x = x :< empty

  (<*>) = ap

is this not a more natural definition?

instance Applicative f => Applicative (Cofree f) where
  pure x = r where
    r = x :< pure r

  (f :< ff) <*> (a :< fa) =
    f a :< liftA2 (<*>) ff fa

[Icelandjack]

It would be a breaking change so it can be attached to a newtype, but it feels a lot more natural to me than the Alternative instance

  pure @(Cofree []) a
= a :< []

-- vs

  pure @(Cofree []) a
= a :< [a :< [a :< [a :< ...