Simple Comonads in Scala?

Question

 trait Comonad[M[_]] {
 // map
 def >>[A,B](a: M[A])(f: A => B): M[B]
 // extract | coeta 
 def counit[A](a:M[A]): A
 // coflatten | comu
 def cojoin[A](a: M[A]): M[M[A]]
}
object Comonad {
 implicit def listComonad[A]: Comonad[List]
 =
 new Comonad[List] {
 def counit[A](lsa: List[A])
 =
 lsa match { case List(a) => a }
 def cojoin[A](lsa:List[A]): List[List[A]]
 =
 List(lsa)
 def >>[A,B](lsa: List[A])(f: A => B): List[B]
 =
 lsa map f
 }
}

So yeah I'm looking at this and I don't have that correct feeling...

Anyone mind correcting this and maybe offerring one or two other simple comonads?

Answer 1

I believe, what's bothering you is a non-total definition of counit, right? (for cojoin one possible variation is lsa.tails) Indeed, a List does not have a valid comonad instance specifically bacause of that. It does have a valid semicomonad instance though.

Things that have a valid comonad instance are, for example: Identity, NonEmptyList, Zipper, Tuple. Here's a reddit question with more examples of comonads.