C# 14 - Simple Lambda Parameters With Modifiers - Inferred Type Arguments

[LeQuackers]

Hi,

This is something else I ran into while playing around with the C# 14 preview:

public static class Extensions
{
    public delegate bool TrySelectDelegate<TSource, TResult>(TSource item, out TResult result);

    public static IEnumerable<TResult> TrySelect<TSource, TResult>(
        this IEnumerable<TSource> source,
        TrySelectDelegate<TSource, TResult> trySelector)
    {
        foreach (var item in source)
        {
            if (trySelector(item, out var result))
            {
                yield return result;
            }
        }
    }

    public static void Test()
    {
        var source = new string[10];

        // CS0411 The type arguments cannot be inferred from usage.
        var validGuids = source.TrySelect((x, out y) => Guid.TryParse(x, out y));
    }
}

With simple lambda parameters with modifiers should this be valid now?

I saw #9453, but I think this is a separate case because this isn't dealing with complex/nested type arguments; TSource is implicitly provided via source and (you'd think) TResult would be inferred by the Guid.TryParse(string, out Guid) method's out parameter.

[jnm2]

I don't believe that this behavior is by design, so this is not a language design bug. Compiler bug reports should be created at https://github.com/dotnet/roslyn/issues/new?template=bug-report.md to get the appropriate eyes on them.

[jnm2]

(@CyrusNajmabadi wdyt?)

[CyrusNajmabadi]

No clue if out params would influence type inference.

I imagine it hasn't been important enough to do.

[jnm2]

What I'm wondering about is specifically if you agree that this is not a lang design question, but an impl bug where the impl has not caught up to the implication of the lang feature.

[timcassell]

Related to type inference, is there a proposal to allow partial type declarations to help with things like this? E.g.

var validGuids = source.TrySelect((x, out Guid y) => Guid.TryParse(x, out y));

It seems that the new feature only deals with param modifiers, and not types.

[LeQuackers]

I opened an issue about it: dotnet/roslyn#79866

[LeQuackers]

I opened an issue about it: dotnet/roslyn#79866

They essentially said "not our problem" and closed it immediately, so it probably has to be submitted as a brand new language proposal.

[333fred]

It's unclear why you think this should work. As an example, here's a version without any out involvment, and demonstrates the same lack of ability to infer:

public static class Extensions
{
    public delegate bool TrySelectDelegate<TSource, TResult>(TSource item, TResult result);

    public static IEnumerable<TResult> TrySelect<TSource, TResult>(
        this IEnumerable<TSource> source,
        TrySelectDelegate<TSource, TResult> trySelector)
    {
        foreach (var item in source)
        {
            TResult result = default!;
            if (trySelector(item, result))
            {
                yield return result;
            }
        }
    }

    public static void Test()
    {
        var source = new string[10];

        // CS0411 The type arguments cannot be inferred from usage.
        var validGuids = source.TrySelect((x, y) => GuidTest.TryParse(x, y));
    }
}

class GuidTest
{
    public static bool TryParse(string s, Guid g) => throw null!;
}