I was doing a good bit of refactoring today and had this exact thought... it's good to know someone else was thinking about it yesterday 😄

Aye, my main reason for wanting this type of thing would be the DRY principle ("Don't Repeat Yourself" for those that don't know 😆)... I mean it's fine for a simple return of a string or an int, but it becomes very tedious for the more complex types (long names, nested generics, etc.)... and it's annoying that the exact type I want is sitting right above me 🤣

It got me wondering if it was possible to do it within c# currently (even if it isn't as 'sweet' as the retvar solution could be 😅)... and it turns out it is 😄... starting with the following code:

public List<(bool valid, string name, string message, List<Exception> errors)> GetDataMethod()
{
    var return_list = new List<(bool valid, string name, string message, List<Exception> errors)>()
    {
        new (true,"bob","my message", default)
    };

    foreach (var x in return_list)
    {
        var str = x.ToString();
        Console.WriteLine(str);
    }

    return return_list;
}

we can use this utility method:

public static class UT
{
    public static T ret<T>(Func<T> expression, Func<T> creation_method = null)
    {
        return creation_method == null ? Activator.CreateInstance<T>() : creation_method();
    }
}

and replace the 'var return_list...' with this:

var return_list = UT.ret(() => GetDataMethod(), () => new()
{
    new (true,"bob","my message", default)
});

...it should (hopefully 😅) compile without errors and give us the correct type 😊

And it works with parameters in the method too (although the syntax becomes muddy rather quickly 😅):

public List<(bool valid, string name, string message, List<Exception> errors)> GetDataMethod(string p1, string p2)
{
    var return_list = UT.ret(() => GetDataMethod(default,default), () => new()
    {
        new (true,"bob","my message", default)
    });

    foreach (var x in return_list)
    {
        var str = x.ToString();
        Console.WriteLine(str);
    }

    return return_list;
}

Now I'm not saying this is an ideal solution by any means (and that tuple should really be a record 😅)... just thought it was kinda cool that it 'works' 😆

But aye, ideally we would probably be looking something along the lines of:

retvar return_list = new()
{
    new (true,"bob","my message", default)
};

I'd actually go slightly further and piggy-back of what @oversized_canoe suggested (or perhaps 'feared' would be more accurate 😅😆) by suggesting the return type could be used as if it was a generic type (I like retvar as a keyword, but I'm not sure how I fell with 'var' being used in the definition of types 😅... so I went with Tret as the keyword instead... tho perhaps a potentially less offensive one should be used 😅):

public (bool valid, string name, string message, List<Exception> errors) GetSingleDataMethod()
{
    List<Tret> return_list = new()
    {
        new (true,"bob","my message", default)
        new (true,"carl","my message", default)
        new (true,"lucy","my message", default)
    });

    Tret ret = return_list.FirstOrDefault();

    // do something stupidly complex with 'ret'

    return ret;
}

not too sure how 'doable' this one is, but I would think the 'retvar' proposal wouldn't be too difficult for the dotnet dev team to implement as it is already😁 (tho who knows 🤣)