Summary

A proposal to introduce a new lightweight early-return syntax, return?, that allows methods to optionally return early when a non-null result is produced — eliminating redundant if (x != null) return x; checks.

Full detailed proposal attached below.

Proposal: return? — Soft or Conditional Return Statement

Author: Hoosein Jafari (By ChatGPT)
Status: Proposed
Language Version: C# (future)
Discussion: [TBD — GitHub Issue URL once created]

Summary

Introduce a new statement form return? <expression>; that allows a method to optionally return early only if the given expression produces a non-null result (or otherwise meaningful value).

This mechanism enables more expressive, cleaner, and safer early-exit flows without explicit null-checks in the caller method.

Motivation

In modern C#, conditional returns are common patterns, especially in validation, authorization, or multi-step methods where each stage may decide to return early.

Example (current C#):

public string HandleRequest(Request req)
{
    var auth = CheckAuth(req);
    if (auth != null)
        return auth;

    var validation = Validate(req);
    if (validation != null)
        return validation;

    return "Success";
}

This pattern is verbose and repetitive, obscuring the main control flow.
The developer’s intent (“return if something is produced”) is diluted by boilerplate code.

Detailed Design

Syntax

A new statement form is introduced:

return? <expression>;

It means:

“If the expression evaluates to a non-null value (or a truthy optional result), return that value immediately. Otherwise, continue execution.”

The expression must be type-compatible with the method’s return type.

Semantics

The compiler would conceptually translate:

return? expr;

to:

{
    var __temp = expr;
    if (__temp != null)
        return __temp;
}

This is purely syntactic sugar and introduces no new runtime behavior.

Nullable and Generic Return Types

If the method’s return type is nullable (T?) or an optional-like generic (Maybe<T>, Option<T>), return? naturally extends to these:

public string? GetResult()
{
    return? TryGetCachedValue();
    return? TryComputeValue();
    return "Default";
}

If neither method yields a value, the method simply continues execution.

Examples

Example 1: Validation Chain

public string ProcessRequest(Request req)
{
    return? CheckAuth(req);
    return? ValidateInput(req);
    return? CheckQuota(req);

    return "Request Accepted";
}

Each call either produces a response (early return) or allows execution to continue seamlessly.

Example 2: Simplifying Nested Logic

public string ProcessData(Data d)
{
    return? EnsureValid(d);
    DoProcessing(d);
    return "Done";
}

Control Flow Safety

• return? does not bypass finally blocks.
• It respects async/await semantics, identical to regular return.
• The compiler ensures the target method still satisfies definite assignment rules for non-nullable return types.

Optional Extension: continue; in Method Scope

An optional conceptual sibling, continue;, could act as “skip current path and return control to caller”, but this remains outside the scope of this proposal.
Future discussion could explore continue; or yield? variants for async and iterator contexts.

Benefits

Drawbacks

• May reduce explicitness for beginners.
• Adds another form of conditional return to learn.
• Needs careful design for non-nullable contexts to avoid implicit null handling.

Alternatives Considered

1. if-return expression

   if (var result = Validate()) return result;

   — existing but verbose.
2. Pattern matching approach

   if (Validate() is { } result) return result;

   — explicit but noisy.
3. Monadic/Optional types (Maybe<T>)
   — powerful but requires extra type wrapping.
4. Soft return operator (return?)
   — simplest, expressive, and clear.

Design Notes

• Compiler can implement this purely as syntactic sugar.
• Static analysis tools (nullable flow analysis) should treat return? as potential early exit.
• No change to runtime or CLR required.

Relationship to Existing Features

• Similar in philosophy to:
  • Null-conditional operator (?.)
  • Null-coalescing assignment (??=)
  • Pattern-based is not null checks
• Follows the language evolution trend toward expressiveness with safety.

Open Questions

1. Should the behavior be limited to reference types (null-based)?
2. Should the compiler treat default(T) as “empty” for value types?
3. How does this integrate with async Task<T> methods?
   (Likely identical translation with await semantics preserved.)

Conclusion

The return? statement offers a simple yet elegant improvement to everyday C# code patterns, reducing noise and improving intent clarity.

By introducing a soft return, developers can write cleaner, more expressive code without changing the underlying semantics of method control flow.

Authored by Hoosein Jafari
Date: October 2025
CSharp_ReturnQuestion_Proposal.md