Скачать или смотреть Understanding Scala Overloading Resolution: Function Calls vs. Implicit Search

Discover the nuances behind `Scala` overloading resolution between function calls and implicit searches. Learn how to effectively utilize implicits and resolve potential ambiguities.
---
This video is based on the question https://stackoverflow.com/q/64361982/ asked by the user 'Readren' ( https://stackoverflow.com/u/1154271/ ) and on the answer https://stackoverflow.com/a/64413338/ provided by the user 'Readren' ( https://stackoverflow.com/u/1154271/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: scala overloading resolution differences between function calls and implicit search

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding Scala Overloading Resolution: Function Calls vs. Implicit Search

In the world of Scala, understanding how the compiler resolves overloaded functions can be quite complex, especially when it comes to implicit searches. If you've ever faced the situation where the compiler behaves differently for a direct function call versus an implicit search, you're not alone. In this guide, we’ll dissect the differences in overloading resolution between these two scenarios, highlighting their implications and providing practical solutions.

The Problem

The crux of the issue lies in how the Scala 2.13.3 compiler determines which overloaded function to call in comparison to which overloaded implicit to select. Here’s a brief overview of the differences:

Function Calls: The compiler filters out alternatives that aren’t assignable and picks the most specific function.

Implicit Search: Similar filtering occurs, but the selection logic behaves differently, creating potential ambiguities in certain cases.

Example Scenario

Let's take a look at a simple example that illustrates this difference:

[[See Video to Reveal this Text or Code Snippet]]

When calling f(new B{}), the compiler correctly resolves to the function designed for B. However, if you try to get an implicit A, the compiler raises an ambiguity error if both B and C are in scope. This leads to confusion: why isn't the implicit instance a chosen when an instance of A is explicitly available?

Exploring Compiler Logic

Step-by-Step Resolution

As noted in the question's edit, the process for both function calls and implicit picks involves two key steps:

Filter: Remove alternatives that aren't assignable to the expected type.

Select: From the remaining options, choose the most specific one or raise an error if there's a tie.

Differences in Assignability

The essential difference arises during the filtering step:

For function calls, only more generic functions than the given argument remain.

For implicits, only more specific instances than the requested type are retained.

This inversion leads to potentially confusing outcomes when invoking implicit resolutions.

Addressing Implicit Resolution Issues

The question then arises—how can we guide the compiler to prefer an implicit instance of the same declared type? A viable solution is to wrap implicit instances in a non-variant wrapper.

Implementation Example

Consider the following implementation for better implicit resolution control:

[[See Video to Reveal this Text or Code Snippet]]

By organizing implicits in a more specific context, we guide the compiler towards a successful resolution without encountering ambiguity.

Conclusion

Understanding the intricacies of how Scala handles overloading resolution between function calls and implicit searches can significantly enhance your programming experience. Remember that while the underlying principles have similarities, the differences in assignability can lead to tricky situations. By practicing the wrapping technique and staying aware of how implicits are resolved, you can avoid pitfalls and write cleaner, more effective Scala code.

With this knowledge, you’ll feel more empowered to tackle complex coding scenarios and engage with Scala's fascinating features!