Inconsistent type inference for context functions and inferable type aliases

[Kordyjan]

In pretty much every situation context functions behave the same as any other type. For example

class Ctx(val value: Double)

trait Wrap[T]:
  def a(x: Double): T
  def b = a(2.0)

val wrapped = new Wrap[Ctx ?=> Double]:
def a(x: Double): Ctx ?=> Double = x * summon[Ctx].value

val res = wrapped.b(using Ctx(3.14))

is a proper, working piece of code. Inference of context function type works as expected.

On the other hand, if the compiler knows ahead that inferred type is going to be the context function, the inference stops working.

def a(x: Double): Ctx ?=> Double = x * summon[Ctx].value
def b = a(2.0)

fails during type-checking. If we explicitly specify the type of b as Ctx ?=> Double it is working.

I assume this is not a bug but a design decision to avoid context bounds propagating upwards. This restriction can be confusing if context-bound is expressed as a type alias, such as in case:

//library code:
type C[T] = Ctx ?=> T

//user code:
val x: C[T] = ???
val y: C[T] = ???
val res = if cond then x else y

that will fail with a confusing error, even though it is something that seems to be reasonable in some DSLs. Also, frequent repetition of types that may be easily inferable can make DSL less readable.

Is it possible to add annotation applicable to type aliases that can make them inferable, even if they are context functions?
Something like:

@inferable type C[T] = Ctx ?=> T

def a(x: Double): C[Double] = x * summon[Ctx].value
def b = a(2.0) // the type of b is inferred

would be perfect for my intended use cases.

[pweisenburger]

I recently came across a similar issue and I agree it would be really helpful if there was a limited way to make context function types inferable to make code cleaner/less verbose. The idea is that you may want to bind some value to a variable and use it as a context function (like in the examples in the first post).

I would imagine something like: For every val/def binding without explicit type ascription, if all “leafs” of the right-hand-side AST agree on the @inferable type, then use it as type for the binding.

So, @inferable would essentially be a small hint to type inference.

Would there be any interest in such a feature?