Partial Override of Parameters: Using+Named Arguments

[MichealZub]

I discovered a strange pattern in Scala 3 that appears to be undocumented: using named arguments within a using clause to override only some context parameters while letting others be resolved from scope.

I searched the documentation, GitHub issues, and forums but found no mention of this.

Key Observations:

• Named arguments work inside using clauses - you can write (using paramName = value)
• Partial override requires trailing () - to override only some parameters:
  ✅ MyClass(using stringParam = "x")()
  ❌ MyClass()(using stringParam = "x") - does not compile
• Unspecified parameters are resolved from givens - the compiler fills in the rest automatically

Questions

1. Is this behavior intentional and stable?
2. If so, could it be documented in the Using Clauses reference?
3. Why is the syntax (using ...)() rather than ()(using ...)?

class MyClass(using intParam: Int, stringParam: String, boolParam: Boolean):
  override def toString = s"int=$intParam, string=$stringParam, bool=$boolParam"

@main def demo(): Unit =
  given Int = 42
  given String = "default"
  given Boolean = true

  // All from scope
  println(MyClass())  
  // int=42, string=default, bool=true

  // Override all explicitly
  println(MyClass(using intParam = 1, stringParam = "explicit", boolParam = false))  
  // int=1, string=explicit, bool=false

  // Partial override — note the trailing ()
  println(MyClass(using stringParam = "partial")())  
  // int=42, string=partial, bool=true

[som-snytt]

Classes require a non-implicit param list, and it was an intentional change that it comes after a contextual param list as in the example. (implicit params are still always trailing.)

Off-the-cuff, I don't know why the last invocation is different, but maybe it just misses the adaptation. If boolParam has a default arg, it will warn that the default is used in preference to the given in scope, since "explicit using" is treated as an explicit application, and only the given int is used.

Edit: oh maybe that's why: the second application infers the missing arg list; the third infers the missing args for the first param list, not the missing param list.

I agree it would be nice to have a doc page, just to illustrate what happens. It's easier to read examples (qua cargo cult) than think through the rules (when there are rules).

Showing the default arg:

class MyClass(using intParam: Int, stringParam: String, boolParam: Boolean = false):
  override def toString = s"int=$intParam, string=$stringParam, bool=$boolParam"

@main def demo(): Unit =
  given Int = 42
  given String = "contextual"
  given Boolean = true

  // All from scope
  println(MyClass())
  // int=42, string=default, bool=true

  // Override all explicitly
  println(MyClass(using intParam = 1, stringParam = "explicit", boolParam = false))
  // int=1, string=explicit, bool=false

  // Partial override — note the trailing ()
  println(MyClass(using stringParam = "partial")())
  // int=42, string=partial, bool=true

then

18 |  println(MyClass(using stringParam = "partial")())
   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |Argument for implicit parameter boolParam was supplied using a default argument.

int=42, string=contextual, bool=true
int=1, string=explicit, bool=false
int=42, string=partial, bool=false