> if (and only if) only one candidate is valid

​

You appear to be under the impression that there is a situation in which there could only be one possible type that could be valid to populate a spefici generic parameter. This is likely not the case. If you have examples please prove me wrong, but **I don't think this situation is possible at the moment.**

​

Your new example doesn't appear to add anything to the scenario. Were you trying to use the `Map` overloads to reduce the number of possible values that `<T2>` could be? If that was your intent, it did not do what you intended. It doesn't matter that you are calling a non-generic method inside the lambda, there are still multiple types that `<T2>` could be:

```cs

using System;

using System.Collections.Generic;

​

public class Example

{

    public void A<T1, T2>(List<T1> list, Action<T1, List<T2>> action) { }

​

    // removed other examples because they are irrelevant

​

    // this does not work by design

    public void F(List<int> input) => A(input, (second, name) => name.Add(Map(second)));

​

    #region Working Examples

​

    public void G(List<int> input) => A(input, (int second, List<int> name) => name.Add(Map(second)));

    public void H(List<int> input) => A(input, (int second, List<MyClass2> name) => name.Add(Map(second)));

    public void I(List<int> input) => A(input, (int second, List<MyStruct2> name) => name.Add(Map(second)));

​

    #endregion

​

    // removed other "Map" methods because they are irrelevant

​

    private int Map(int item) => 10;

}

​

public class MyClass2

{

    public static implicit operator MyClass2(int a) => new MyClass2();

}

​

public struct MyStruct2

{

    public static implicit operator MyStruct2(int a) => new MyStruct2();

}

```