[Proposal] Default method return value

[MV10]

Quite regularly, I write methods that exit early with some default value (most commonly null or true or false). It would be handy if the method return value supported syntactic sugar to specify a default, such that the code could simply invoke return; to exit. Such a method signature also provides useful information to the caller.

A trivial example declaring that false is the default return value:

// declares a default return value of false
public bool = false IsValid(string foo, string bar)
{
    if(string.IsNullOrEmpty(foo) || string.IsNullOrEmpty(bar))
    {
        return; // returns false
    }

    // do other useful stuff
    return true;
}

I recognize this could become somewhat messy-looking for returning complex types, but in my experience those aren't common default return values. While it isn't my preference, I also considered syntax within the method itself:

public bool IsValid(string foo, string bar)
{
    // declare the default return value
    default return = false;
    
    if(string.IsNullOrEmpty(foo) || string.IsNullOrEmpty(bar))
    {
        return; // returns false
    }

    // do other useful stuff
    return true;
}

That syntax would also make it more "sensible" to do things like make an input argument the default return value, although I think I still prefer that the default is part of the signature. I suppose it could also be confusing versus the current meaning of the default keyword, such as return default; so I pondered a third approach (which is somewhat reminiscent of property default values):

public bool IsValid(string foo, string bar)
{
    if(string.IsNullOrEmpty(foo) || string.IsNullOrEmpty(bar))
    {
        return; // returns false
    }

    // do other useful stuff
    return true;
} = false; // declare the default return value

However, this wouldn't work with expression-bodied methods, as far as I can see.

For return types involving generics, I'm not sure supporting default return values makes sense (or perhaps there could be a rule that only null is permitted), but again, I haven't really seen many cases where a complex type is a default return value (and return default(T) does work, so maybe my concern is misplaced).

This probably fails the LDT's "effort / value" tradeoff, but it has occurred to me many times over the years (often when I can't remember what some call's default is, so as the consumer I wish it was explicit and reported by Intellisense), so I figured I'd throw it out there.

[HaloFour]

IMO, the existing syntax is much clearer and easier to read, despite being more verbose. As for what a method might return in different circumstances, that is what documentation comments are for. Even if there was a concept of a "default" return value, you'd still need some kind of description as to when it actually would apply.

[Trarizon]

Sometimes I do this for returning default value:

bool Method()
{
    if (!Check1()) goto ReturnFailed;
    if (!Check2()) goto ReturnFailed;

    // Method body
    return true;

ReturnFailed:
    return false;
}

I think it is clear enough.

[jnm2]

Love seeing people realize they don't need permission from the universe to use goto :D