Implicit val can't be annotated with any type so that the code compiles https://stackoverflow.com/questions/55548968/how-to-use-functors-with-scala-cats/55549231#comment97803502_55549231

App.scala

object App {

  trait MyTrait
  object MyTrait {
    def materialize[A <: MyTrait](implicit m: A): A = m
  }

  implicit val m/*: MyTrait*/ /*: (MyTrait {
    /*implicit*/ val x: Int
    })*/ = new MyTrait {
    implicit val x: Int = 10
  }

  val m1 = MyTrait.materialize
  import m1._
  implicitly[Int]

}

BTW, just to propose a counter example this will work.

object App {
  trait MyTrait {
    type T
    implicit def t: T
  }
  object MyTrait {
    def materialize[A](implicit m: MyTrait { type T = A}): MyTrait { type T = A}= m
  }

  implicit val m: MyTrait { type T = Int } = new MyTrait {
    override type T = Int
    override implicit val t: T = 42
  }
  val m1 = MyTrait.materialize[Int]
  import m1._
  println(implicitly[Int]) // 42.
}

Better yet, use type parameters instead of type members, which aren't needed at all in this example.

-- Sincerely, Luis Miguel Mejía Suárez.

@BalmungSan well, you changed the trait. This can be a third-party type class.

Usually with type classes type parameters are used as inputs and type members as outputs.

https://chat.stackoverflow.com/rooms/191377/discussion-between-dmytro-mitin-and-luis-miguel-mejia-suarez

object App {
  class A
  class B
  class C
  class D

  trait MyTrait[A]
  object MyTrait {
    def materialize[A] = new Helper[A]

    class Helper[A] {
      def apply[MT <: MyTrait[A]](implicit mt: MT): MT = mt
    }

    implicit val intMT = new MyTrait[Int] {
      implicit val a: A = new A
      implicit val b: B = new B
    }

    implicit val stringMT = new MyTrait[String] {
      implicit val c: C = new C
      implicit val d: D = new D
    }
  }

  {
    val m = MyTrait.materialize[Int].apply
    import m._
    implicitly[A]
    implicitly[B]
  }

  {
    val m = MyTrait.materialize[String].apply
    import m._
    implicitly[C]
    implicitly[D]
  }

}

import shapeless.{::, HList, HNil, Poly2}

object App {

  def swap(p: Poly2)/*: Poly2*/ /*: (Poly2 {
    /*implicit*/ def cse[L <: HList, A, B](implicit
                                       ev: L <:< (A :: B :: HNil),
                                       pCase: p.Case[B, A]
                                      ): ProductCase.Aux[L, pCase.Result]
  })*/ = new Poly2 {
    implicit def cse[L <: HList, A, B](implicit
                                       ev: L <:< (A :: B :: HNil),
                                       pCase: p.Case[B, A]
                                      ): ProductCase.Aux[L, pCase.Result] = ProductCase(l => {
      val a :: b :: HNil = ev(l)
      pCase(b, a)
    })
  }

  object myPoly extends Poly2 {
    implicit val intCase: Case.Aux[Int, Boolean, Long] = at((i, _) => i.toLong)
    implicit val strCase: Case.Aux[String, Char, Symbol] = at((s, c) => Symbol(s + c))
  }

  val myPoly1 = swap(myPoly)
  import myPoly1._
  myPoly1(true, 10)
  myPoly1('c', "ab")
}