`given` cannot express implicit conversion using cbn parameter

[two-horned]

Sometimes it is crucial to convert types without evaluating the value.
For example, like this:

implicit def toB[R](x: => A[R]): B[R] = B(myFun(x))

There exists no equivalent given statement, which I wish would.

If I define a given [R]: Conversion[A[R], B[R]], the apply function has to have type A[R] as parameter, disallowing type => A[R]. So currently I am forced to use the implicit def, which is at odds with modern
coding style that uses given.

[Gedochao]

So currently I am forced to use the implicit def, which is at odds with modern
coding style that uses given.

While I agree that codebases should migrate to given if at all able, implicit won't be deprecated before Scala 3.10.
So what I'm saying, it's fine to stay on implicit at this moment in time (even if it feels off).

Now, as for the main issue, for a full example.
If I understand correctly, your current code looks like this:

import scala.language.implicitConversions
class A[T](val field: T)
case class B[T](value: T)
def myFun[T](a: A[T]): T = a.field
implicit def toB[R](x: => A[R]): B[R] = B(myFun(x))

(the reproduction in the OP isn't a full compiling one)

EDIT: Ah, I see the nuance.

The following compiles, too:

import scala.language.implicitConversions
class A[T](val field: T)
case class B[T](value: T)
def myFun[T](a: A[T]): T = a.field
given a2B[R]: Conversion[A[R], B[R]] with
  def apply(x: A[R]): B[R] = B(myFun(x))

But this does not:

import scala.language.implicitConversions
class A[T](val field: T)
case class B[T](value: T)
def myFun[T](a: A[T]): T = a.field
given a2B[R]: Conversion[A[R], B[R]] with
  def apply(x: => A[R]): B[R] = B(myFun(x))

getting us the following error:

-- Error: ~/compiler-repro/repro.scala:5:6 
5 |given a2B[R]: Conversion[A[R], B[R]] with
  |      ^^^
  |instance cannot be created, since def apply(x: T): U in class Conversion in package scala is not defined 
  |(Note that
  | parameter T in def apply(x: T): U in class Conversion in package scala does not match
  | parameter => A[R] in def apply(x: => A[R]): B[R] in class a2B
  | )

I guess the example we have at https://docs.scala-lang.org/scala3/book/ca-implicit-conversions.html#detailed-explanation is a simple one...

I'm not entirely sure if this is a bug, missing feature, or perhaps there's something we're missing here...

[Gedochao]

cc @odersky

[odersky]

I wonder whether this could be handled by SIP 68 if it arrives, or whether something else is needed.

scala/improvement-proposals#86