Trailing Lambda Syntax

[Adiras]

Overview

Introduce a syntax in C# that allows developers to pass lambda expressions as the last parameter of a method outside the parentheses, enhancing readability, particularly in cases involving long or multiline lambdas. This feature draws inspiration from Kotlin language syntax. Additionally, for lambdas with exactly one parameter, the implicit variable it can be used without having to explicitly declare the parameter.

Motivation

In the current version of C#, lambdas must be written inside the parentheses of method calls:

DoSomething(() => {
    Console.WriteLine("Hello");
});

For methods where the last parameter is a lambda expression, this syntax can become cumbersome, especially when the lambda is long or multiline. The proposed trailing lambda syntax offers an improved, cleaner way to write such code:

DoSomething {
    Console.WriteLine("Hello");
};

Syntax

• General Rule: If the last parameter of a method is a delegate or lambda expression, it can be written outside the parentheses.
• Other parameters: Any other parameters must remain inside the parentheses.
• Single-parameter lambdas: When a lambda expression has exactly one parameter, it can be used implicitly inside the lambda body, eliminating the need to declare a formal parameter.

Examples:

void Execute(int times, Action action) { ... }

// Current syntax
Execute(3, () => {
    Console.WriteLine("Hello");
});

// Proposed trailing lambda syntax
Execute(3) {
    Console.WriteLine("Hello");
};

For parameterless methods:

// Current
Task.Run(() => {
    Console.WriteLine("Done");
});

// Proposed
Task.Run {
    Console.WriteLine("Done");
};

For single-parameter lambdas:

void Repeat(int times, Action<int> action) { ... }

// Current
Repeat(5, i => Console.WriteLine(i));

// Proposed with trailing lambda
Repeat(5) {
    Console.WriteLine(it); // 'it' is implicit
};

Rules

• Trailing lambda: Can only be used for the last parameter of the method.
• Optional Parameters: If the last parameter is optional, it can be omitted.
• Multiple Delegate Parameters: If there are multiple delegate parameters, only the last one can be written with trailing syntax.
• Single Expression: The trailing lambda must be a single lambda expression, not multiple expressions separated by commas.
• Implicit it: If the lambda has exactly one parameter, it is available implicitly within the lambda body.

Benefits

• Improved Readability: Especially for long or multiline lambdas, the trailing syntax reduces nesting of parentheses and improves clarity.
• Simplified Code: For many higher-order functions and LINQ methods, the new syntax makes code more concise and eliminates unnecessary boilerplate.
• Encourages Functional Patterns: Aligns with functional programming paradigms, making C# more expressive and elegant.
• Cleaner Syntax for Simple Lambdas: The ability to omit the explicit declaration of a single parameter in lambdas like in LINQ expressions makes C# more user-friendly.

Real-World / DSL Scenarios

UI Layout DSL

The trailing lambda syntax helps build complex UI hierarchies in a clean and intuitive way, mimicking the structure of a declarative DSL.

// Current syntax
Window("Main Window", () => {
    Button("Click me", () => {
        Console.WriteLine("Button clicked!");
    });

    TextBox("Enter your name");

    Button("Submit", () => {
        Console.WriteLine("Submit clicked!");
    });
});

// Proposed trailing lambda syntax
Window("Main Window") {
    Button("Click me") {
        Console.WriteLine("Button clicked!");
    }
    TextBox("Enter your name")
    Button("Submit") {
        Console.WriteLine("Submit clicked!");
    }
};

Fluent API for Configuration

When defining configuration blocks, the proposed syntax leads to more readable and structured code.

// Current syntax
ConfigureServer("localhost", () => {
    Port(8080);
    UseHttps();

    Routes(() => {
        Get("/home", () => {
            Console.WriteLine("Home page");
        });

        Post("/login", () => {
            Console.WriteLine("Login");
        });
    });
});

// Proposed trailing lambda syntax
ConfigureServer("localhost") {
    Port(8080)
    UseHttps()
    Routes() {
        Get("/home") { Console.WriteLine("Home page"); }
        Post("/login") { Console.WriteLine("Login"); }
    }
};

LINQ

Complex LINQ queries become more concise and expressive, eliminating unnecessary lambda parameter declarations.

// Current syntax
var adults = people
    .Where(person => person.Age >= 18)
    .Select(person => person.Name)
    .ToList();

// Proposed trailing lambda syntax
var adults = people
    .Where { it.Age >= 18 }
    .Select { it.Name }
    .ToList();

[HaloFour]

See: #1151