Generic actual inference

[QuentinOchem]

No description provided.

[thvnx]

This RFC is fundamentally a name-resolution change, so could you specify precisely how inference composes with overload resolution: in what order they run, which entities participate, and exactly which cases are considered ambiguous and rejected.

That precision matters for cost too: implementing this will be significant work in both GNAT and Libadalang, and their resolvers can only do it against well-defined name-resolution rules.

[sttaft]

In the Prior Art section, you might want to talk about other languages that have done something similar. I asked Google: "What languages support implicit instantiation as part of function call" and here is the response:

Programming languages that use generics or templates and perform type inference during a regular function call support implicit instantiation (automatically generating a specialized function for specific types based on the arguments provided). [1, 2]

Languages with Implicit Instantiation on Function Calls

• C++: The classic example. When you call a C++ Function Template with concrete arguments (e.g., max(1, 2)), the compiler implicitly instantiates the matching specialization (max). [1, 2]
• Rust: Generic functions are implicitly instantiated (monomorphized) by the compiler when invoked with specific concrete types without requiring manual type parameters in the call syntax (e.g., some_function(5)infers ).
• Swift: Uses generic functions where type parameters are implicitly deduced from function call arguments.
• D: Supports function templates that implicitly instantiate based on the types of arguments passed during a call.
• Scala (with generics/polymorphic methods): Type parameters on methods are inferred implicitly at the call site.