Scala 3 compiletime: value from type - scala

Question

I want to initialize a val with the value of a type parameter:
import scala.compiletime.constValue
trait Foo[N <: Int]:
val m:Int=constValue[N]
val two = new Foo[2]{}.m
I get an error:
-- Error: ---------------------------------------------------------------
5 | val m:Int=constValue[N]
| ^^^^^^^^^^^^^
| not a constant type: Foo.this.N; cannot take constValue
How do I tell it to calculate m only after N is known?
(Well, in fact, I want something a bit more complex:
trait Foo[N <: Int]:
transparent inline def something[N]:Int = ??? // constValue[N] inside
val m:Int=something[N]
but it fails on constValue[N])

Answer 1

N is known (should) when you are creating this trait. So you could pass it in a constructor argument of a trait
trait Foo[N <: Int](using N: ValueOf[N]):
val m: Int = N.value
ValueOf[N] would be then provided when you instantiate the value
object Bar extends Foo[5]
println(Bar.m)
If you defer it further, you'd have to pass ValueOf[N] up till then place when it is known
def create[N <: Int : ValueOf]: Foo[N] =
new Foo[N] {}
println(create[4].m)
constValue[N] would work if N was known e.g. if it was defined as
type N = 5
or if it was used inside an inline method which known the type of N <: Int passed into it
inline def something[N <: Int]: Int = scala.compiletime.constValue[N]
println(something[3])
In your second example you have two N defined, it would partially work if you did
trait Foo[N <: Int]:
inline def something: Int = scala.compiletime.constValue[N]
println(new Foo[2]{}.something)
partially because something knows N when called from outside in the context where the exact type is known. Within Foo this is not true, so
val m: Int = something
will always fail.