Ambiguous implicit found: conflicting given instances in Scala 3 trait inheritance

In Scala 3, the Ambiguous implicit found error occurs when the compiler identifies multiple given instances that satisfy a requirement but cannot determine a winner. When a class inherits multiple traits that each provide a given for the same type, and the class itself defines its own given, the search space contains at least three valid candidates.

The Source of the Ambiguity

The Scala 3 implicit search algorithm operates on specificity and scope. While locally defined given instances generally have higher priority than inherited ones, ambiguity arises primarily when two inherited traits provide instances of the same specificity level. Because the compiler does not have a 'tie-breaking' rule for sibling traits, it throws an error to prevent unpredictable behavior.

Resolution Strategies

To resolve this without using compiler hacks, consider the following approaches:

• Explicit using Clause: The most direct fix is to specify which given instance to use at the call site. This bypasses the search mechanism by providing the instance directly:

  def process(using instance: MyType) = { ... }

• Trait Consolidation: If you control the traits, move the given definition to a common base trait or a shared object to ensure only one instance enters the scope.
• Shadowing via Local Definition: If you want the class's specific given to win, ensure it is the only valid candidate. However, if the inherited instances are still in scope, the compiler may still complain unless the local definition effectively narrows the search path.
• Scoped Imports: Use explicit import statements to bring only specific given instances into the scope where the ambiguity occurs.

Assumptions and Uncertainty

This explanation assumes you are using standard Scala 3.x implicit resolution. It is important to note that the language specification prioritizes specificity (type depth) but does not guarantee an order of inheritance-based precedence for traits at the same level. If your architecture relies on complex multiple inheritance where given instances are generated dynamically, the behavior may remain fragile across future updates to the compiler's search heuristics.