Abstract Over TypeClass

Question

Starting with some simple code:

trait Moveable[A] {
  def move(a: A): A
}
trait Animal {
  def kick[A <: Animal: Moveable](a: A): A = implicitly[Moveable[A]] move a
}
object Cat {
  implicit object CatMoveable extends Moveable[Cat] {
    def move(cat: Cat): Cat = cat copy (pos = cat.pos + 4)
  }
}
case class Cat(pos: Int) extends Animal
case class Dog(pos: Int) extends Animal
val someAnimal: Animal = Dog(0)
val kickedCat: Cat = someAnimal kick Cat(0)
println(kickedCat) // Cat(4)

I decided to distinguish between, let´s say, Quadruped and Biped animals:

trait FourFeetMoveable[A] {
  def moveWithFourFeets(a: A): A
}
trait TwoFeetMoveable[A] {
  def moveWithTwoFeets(a: A): A
}
trait Animal {
  def kick[A <: Animal /*: ??? */](a: A): A
}
trait Quadruped extends Animal {
  def kick[A <: Animal: FourFeetMoveable](a: A): A = implicitly[FourFeetMoveable[A]] moveWithFourFeets a
}
trait Biped extends Animal {
  def kick[A <: Animal: TwoFeetMoveable](a: A): A = implicitly[TwoFeetMoveable[A]] moveWithTwoFeets a
}
object Chicken {
  implicit object ChickenTwoFeetMoveable extends TwoFeetMoveable[Chicken] {
    def moveWithTwoFeets(chicken: Chicken): Chicken = chicken copy (pos = chicken.pos + 2)
  }
}
case class Dog(pos: Int) extends Quadruped
case class Chicken(pos: Int) extends Biped
val someAnimal: Animal = Dog(0)
val kickedChicken: Chicken = someAnimal kick Chicken(0)
println(kickedChicken) // Chicken(2)

A must have is to have two totally different typeclasses FourFeetMoveable and TwoFeetMoveable, so I can´t abstract over them with something like this:

trait Moveable[A] {
  def move(a: A): A
}

So how can I abstract over the typeclasses used as a context bound at method kick in trait Animal(see the ???)?

EDIT

Sorry, I should have made my example clearer. Lets say the effect of being kicked can be some movement or some other action. I wanted to abstract over that effect with a typeclass. In the following code I am showing what I mean and also used an abstract type member KickingEffect to abstract over the required typeclass, as 0__ proposed:

trait StumbleEffect[A <: Animal] {
  def stumble(a: A): A
}
trait GlideEffect[A <: Animal] {
  def glide(a: A): A
}
trait Animal {
  type KickingEffect[A <: Animal]
  def kick[A <: Animal: KickingEffect](a: A): A
}
trait Biped extends Animal {
  type KickingEffect[A <: Animal] = StumbleEffect[A]
  override def kick[A <: Animal: StumbleEffect](a: A): A = implicitly[StumbleEffect[A]] stumble a
}
trait Quadruped extends Animal {
  type KickingEffect[A <: Animal] = GlideEffect[A]
  override def kick[A <: Animal: GlideEffect](a: A): A = implicitly[GlideEffect[A]] glide a
}
object Dog {
  implicit object DogGlideEffect extends GlideEffect[Dog] {
    def glide(dog: Dog): Dog = dog copy (pos = dog.pos + 4)
  }
}
case class Dog(pos: Int) extends Quadruped
case class Cat(pos: Int) extends Quadruped
case class Chicken(pos: Int) extends Biped

But then I ran into another problem, when it comes to sequences of animals:

type Beast[A <: Animal, KE[_ <: Animal]] = A { type KickingEffect[X <: Animal] = KE[X] }
val dogBeast: Beast[Dog, GlideEffect] = Dog(0) // fine

type GlideBeasts[A <: Quadruped] = Beast[A, GlideEffect]
val glideBeasts: Seq[GlideBeasts[Quadruped]] = Seq(Dog(0), Cat(0)) // fine

def kickAll[A <: Animal, KE[_ <: Animal], KA <: Animal](kicker: Beast[A, KE])(animals: Seq[KA])(implicit ev: kicker.KickingEffect[KA]): Seq[KA] = {
  for (a <- animals) yield kicker kick a
}
val cat = Cat(0)
val dog = Dog(0)
kickAll(cat)(Seq(dog)) // wrong inferred kinds of type arguments
kickAll[Cat, GlideEffect, Dog](cat)(Seq(dog)) // missing implicit evidence

Answer 1

As a side note, I found it always useful to not introduce type bounds till the moment they are really needed. Not only do you safe a lot of typing (no pun intended), but you keep options open (e.g. for later variance annotations). The following is totally sufficient:

trait StumbleEffect[A] {
  def stumble(a: A): A
}
trait GlideEffect[A] {
  def glide(a: A): A
}
trait Animal {
  type KickingEffect[A]
  def kick[A : KickingEffect](a: A): A
}
trait Biped extends Animal {
  type KickingEffect[A] = StumbleEffect[A]
  override def kick[A : StumbleEffect](a: A): A = 
    implicitly[StumbleEffect[A]] stumble a
}
trait Quadruped extends Animal {
  type KickingEffect[A] = GlideEffect[A]
  override def kick[A : GlideEffect](a: A): A = implicitly[GlideEffect[A]] glide a
}

etc.

Answer 2

Like this?

trait Moveable[A] {
  def move(a: A): A
}
trait FourFeetMoveable[A] extends Moveable[A]
trait TwoFeetMoveable[A] extends Moveable[A]

trait Animal {
  type CanKick[A] <: Moveable[A]
  def kick[A <: Animal : CanKick](a: A): A = implicitly[CanKick[A]] move a
}
trait Quadruped extends Animal {
  type CanKick[A] = FourFeetMoveable[A]
}
trait Biped extends Animal {
  type CanKick[A] = TwoFeetMoveable[A]
}

---

Regarding your edit: I would recommend at this point not to further try to model that with types, unless it is really an extremely crucial point in your application or a pure thought experiment. You can get easily overambitious with type-safe design, then the ratio between design effort and application value is getting to big; I would just drop some compile-time safety and go for pattern matching and runtime errors.

If you do want to follow the types route, as soon as you have collections, you will need something like HLists to preserve the individual types of the collection members.

---

Anyway, you can make your example work (with explicit type parameters):

def kickAll[A <: Animal, KE[_ <: Animal], KA <: Animal](
   kicker: Beast[A, KE])(animals: Seq[KA])(implicit effect: KE[KA]): Seq[KA] = {
      for (a <- animals) yield kicker kick a
}

val cat = Cat(0)
val dog = Dog(0)
kickAll(cat)(Seq(dog)) // still doesn't figure out the types
kickAll[Cat, GlideEffect, Dog](cat)(Seq(dog)) // ok!

As said, the tricky or impossible part comes when you try to do this with heterogeneous lists (e.g. requiring different effects). You might get away with using a helper type class for the elements of the sequence, instead, so that implicits can be resolved per item before.