A difference between infix and dot notation for generic methods

Language Design
1

In this program, the last line does not compile (syntax error for the [Int]).

class A:
  def f[X](s:String) = new B[X]
  infix def g[X](s:String) = new B[X]

class B[X]

val a = new A
val b1 = a.f[Int]("abc")  // ok
val b2 = a g[Int] "abc"   // does not compile

Is it the expected behavior? Why such a difference between infix and dot notation?

2

The feature (infix type arg) was added to Scala 2 at some point on a lark.

I read somewhere that this was looked upon askance in Scala 3. If I find the link, I’ll add it.

Basically, infix notation was not conceived as a generic (pun intended) replacement for dotted invocation.

If you have to ask what 2 + 2 means (because polymorphic), maybe it’s not appropriate.

3

Wait, x + y doesn’t compile if the signature of x.+ is def +[A](a: A) = ????

4

In your case, it compiles because the [A] can be inferred from the type of a.
However, I’d like to have a similar behaviour for generic infix and dot invocation.

5

It was an easy issue search for infix:

where my comment includes a link to further historical commentary.

it’s called Dotty because it is opinionated about dots.

1 Like