Took a while to get Unapply working. . . very open to some code review

1.syntax.scala

case class ProcessMSyntax[F[_], MM[_], A]
    (self: Process[F, MM[A]], trav: Traverse[MM]) {

  def throughM[MB]
      (c: Channel[F, A, MB])
      (implicit
        uBindB: Unapply[Bind, MB] { type M[X] = MM[X] })
      : Process[F, uBindB.M[uBindB.A]] = {
    val substC = uBindB.leibniz.subst[Channel[F, A, ?]](c)
    ProcessFunctions.throughChannelM(self, substC)(uBindB.TC, trav)
  }

}

implicit def processSyntax[F[_], MA]
    (p: Process[F, MA])
    (implicit ev: Unapply[Traverse, MA])
    : ProcessMSyntax[F, ev.M, ev.A] =
  ProcessMSyntax(ev.leibniz.subst[Process[F, ?]](p), ev.TC)

2.callsite.scala

// This implicit seems to need to be in scope at the call site
implicit def ev[A] = Unapply[Bind, StreamFault \/ A]

ReadDomains
  .process(timestamp, domainFn)(builtwithOutput)
  .throughM(WriteSSTables.channel(dir, sql, keyspace, table))
  .run
  .liftM[ActionT]

3.error.txt

Here's the error (cleaned up a bit) I get if I don't have the implicit in scope:


[error] could not find implicit value for parameter uBindB:

    Unapply[Bind, StreamFault \/ Unit] { type M[X] = StreamFault \/ X }

[error]         .throughM(WriteSSTables.channel(dir, sql, keyspace, table))
[error]                  ^
[error] one error found