instance Functor fs => Functor (Cons fs) where
  fmap f (Cons a fs) = Cons (f a) (fmap f fs)

instance Functor Nil where
  fmap _ Nil = Nil

instance Functor fs => Functor (Unary fs) where
  fmap f (Z ffs) = Z $ fmap (fmap f) ffs
  fmap f (S n)   = S (fmap f n)

instance Foldable Nil where
  foldr f z Nil = z

instance Foldable fs => Foldable (Cons fs) where
  foldr f z (Cons a fs) = a `f` foldr f z fs

instance Foldable fs => Foldable (Unary fs) where
  foldr f z (Z ffs) = foldr (flip $ foldr f) z ffs
  foldr f z (S n)   = foldr f z n

instance Traversable Nil where
  traverse _ Nil = pure Nil

instance Traversable fs => Traversable (Cons fs) where
  sequenceA (Cons ma fms) = Cons <$> ma <*> sequenceA fms

instance Traversable fs => Traversable (Unary fs) where
  sequenceA (Z ffms) = Z <$> sequenceA (fmap sequenceA ffms)
  sequenceA (S n)    = S <$> sequenceA n