A pattern for binding a typeclass to a value, but forgetting the container type in scala.

WithTC.scala

package WTC

import cats._
import cats.implicits._

abstract class WithTC[TC[_[_]], A] {
  type F[_]

  val value: F[A]

  val typeClass: TC[F]
}

object WithTC {
  final class Builder[TC[_[_]]] {
    def apply[F1[_], A](fa: F1[A])(implicit tc: TC[F1]): WithTC[TC, A] =
      new WithTC[TC, A] {
        type F[x] = F1[x]
        val value = fa
        val typeClass = tc
      }
  }
  def apply[TC[_[_]]]: Builder[TC] =
    new Builder[TC]


  // note, we don't know what the container is here,
  def onFoldable(tc: WithTC[Foldable, Int]): List[Int] =
    tc.typeClass.toList(tc.value)

  onFoldable(WithTC[Foldable](Vector(1, 2, 3)))

  onFoldable(WithTC[Foldable](List(1, 2, 3)))

  // we can convert to List. We could even have a List[WithTC[Foldable, Int]]
  def flatten(wcs: List[WithTC[Foldable, Int]]): List[Int] =
    wcs.flatMap(onFoldable(_))

  flatten(List(WithTC[Foldable](List(1, 2, 3)), WithTC[Foldable](Vector(4, 5, 6))))
}