如果我没理解错的话你希望

def toCaseClass[A, R <: HList, L <: HList](implicit 
  g: Generic.Aux[A, R], 
  r: Reverse.Aux[L, R]
): L => A = l => g.from(l.reverse)

您只能指定A，然后推断出R、L。
您可以使用PartiallyApplied模式执行此操作

import shapeless.ops.hlist.Reverse
import shapeless.{Generic, HList, HNil}

def toCaseClass[A] = new {
  def apply[R <: HList, L <: HList]()(implicit 
    g: Generic.Aux[A, R], 
    r0: Reverse.Aux[R, L], 
    r: Reverse.Aux[L, R]
  ): L => A = l => g.from(l.reverse)
}

class A
class B
val a = new A
val b = new B
case class Result(a: A, b: B)

toCaseClass[Result]().apply(b :: a :: HNil)

（没有隐式r0类型参数，在调用.apply()时不能推断L，因为L只有在调用.apply().apply(...)时才变为已知）
或更好

def toCaseClass[A] = new {
  def apply[R <: HList, L <: HList](l: L)(implicit 
    g: Generic.Aux[A, R], 
    r: Reverse.Aux[L, R]
  ): A = g.from(l.reverse)
}

toCaseClass[Result](b :: a :: HNil)

(here我们不需要r0，因为L在调用.apply(...)时已经变为已知的）。
如果需要，可以将匿名类替换为命名类

def toCaseClass[A] = new PartiallyApplied[A]

class PartiallyApplied[A] {
  def apply...
}

或者，您可以定义一个类型类（尽管这样做有点罗嗦）

trait ToCaseClass[A] {
  type L
  def toCaseClass(l: L): A
}
object ToCaseClass {
  type Aux[A, L0] = ToCaseClass[A] { type L = L0 }
  def instance[A, L0](f: L0 => A): Aux[A, L0] = new ToCaseClass[A] {
    type L = L0
    override def toCaseClass(l: L0): A = f(l)
  }
  implicit def mkToCaseClass[A, R <: HList, L <: HList](implicit
    g: Generic.Aux[A, R],
    r0: Reverse.Aux[R, L],
    r: Reverse.Aux[L, R]
  ): Aux[A, L] = instance(l => g.from(l.reverse))
}

def toCaseClass[A](implicit tcc: ToCaseClass[A]): tcc.L => A = tcc.toCaseClass

toCaseClass[Result].apply(b :: a :: HNil)

使用类型类隐藏几个隐式表达式：How to wrap a method having implicits with another method in Scala?
您可以在 * 键入宇航员 * 中找到问题的答案：
https://books.underscore.io/shapeless-guide/shapeless-guide.html#sec:ops:migration (6.3案例研究：案例类迁移）
请注意，IceCreamV1("Sundae", 1, true).migrateTo[IceCreamV2a]接受一个单一类型参数。
您的GraphOps代码由于以下几个原因无法工作。
首先，shapeless.Lazy不仅仅是一个 Package 器，它是一个基于宏的类型类，用来处理“发散隐式扩展”（在Scala 2.13中有by-name=>隐式表示，尽管它们不等价于Lazy）。
其次，您似乎定义了一些隐式转换（隐式视图，Mat => A），但隐式转换的解析比其他隐式转换的解析更棘手（12345）。
第三，你似乎假设当你定义

implicit def foo: Foo = ???

def useImplicitFoo(implicit foo1: Foo) = ???

foo1是foo，但一般情况下不是这样的，foo是在当前作用域中定义的，foo1将在useImplicitFoo调用站点的作用域中解析：
Setting abstract type based on typeclass
When doing implicit resolution with type parameters, why does val placement matter?（implicit x: X与implicitly[X]之间的差值）
所以当你调用toCaseClass时，隐式的createConverter不在作用域中。
代码的修复版本为

trait RunnableGraph[Mat]{
  def mapMaterializedValue[A](a: Mat => A): RunnableGraph[A]
}

case class Wrapper[A, B](value: A => B)

implicit class GraphOps[Mat <: HList](g: RunnableGraph[Mat]) {
  val ops = this

  implicit def createConverter[A, RL <: HList](implicit
    r: Reverse.Aux[Mat, RL],
    gen: Generic.Aux[A, RL],
  ): Wrapper[Mat, A] =
    Wrapper { l =>
      val x: RL = l.reverse
      val y: A = gen.from(x)
      gen.from(l.reverse)
    }

  def toCaseClass[A](implicit convert: Wrapper[Mat, A]): RunnableGraph[A] = {
    g.mapMaterializedValue(convert.value)
  }
}

val g: RunnableGraph[B :: A :: HNil] = ???
val ops = g.ops
import ops._
g.toCaseClass[Result]

尝试

import akka.stream.scaladsl.RunnableGraph
import shapeless.{::, Generic, HList, HNil}
import shapeless.ops.hlist.Reverse

implicit class GraphOps[Mat <: HList, R <: HList](g: RunnableGraph[Mat]) {
  def toCaseClass[A](implicit
    r: Reverse.Aux[Mat, R],
    gen: Generic.Aux[A, R]
  ): RunnableGraph[A] = g.mapMaterializedValue(l => gen.from(l.reverse)) 
}

case class Result(one: String, two: Int)

val g: RunnableGraph[Int :: String :: HNil] = ???
g.toCaseClass[Result]