Feature request: Imporve C# syntax

[Valensm]

Ideas to Improve the C# Syntax

Primary Constructors with Auto Properties

class Example(public Int Count)
{
 ...
}

should be equivalent of

class Example(Int count)
{
    public Int Count { get; set; } = count
}

The optional readonly modifier can introduce property with the getter only.

Benefits

• shorter syntax
• reduce boiler plate

Custom DSL syntax support

When a delegate (Action<> or Funct<>) is the last parameter of a method, the call can be simplified to move the delegate out of brackets. If the delegate is the only parameter, then even omit the brackets entirely.

A method:

public static void Also<T>(this T what, Func<T, T> func)
{
    return func(what);
}

Usage:

new Builder()
    .ConfigureConnection()
    .AddFeatures(...)
    .Build()
    .Also { b =>
        logger.debug($"Builder has been built with features {b.Features}.")
    };

Without it:

var builder = new Builder()
    .ConfigureConnection()
    .AddFeatures(...)
    .Build();
logger.debug($"Builder has been built with features {builder.Features}.");

And in addition if there is this modifier, it allows to write inline extensions:

class DependencyHandler 
{
    public void Compile(string coordinate)
    {
        // add coordinate to some collection
    }
    public void  TestCompile(string coordinate){
        // add coordinate to some collection
    }
}

class Project
{
    // This is the method accepting extension a first parameter
    public static Project Create(Action<this Project> action)
    {
        var project = new Project();
        action(project);
        return project;
    }
    public DependencyHandler Dependencies(Action<this DependencyHandler> action)
    {
        var dependencies = new DependencyHandler();
        dependencies.action();
        return dependencies;
    }
    public void Run()
    {
        // some code to execute
    }
}

static class 

And now the usage:

static class Foo
{
    public static void Bar()
    {
        Project.Create
        {
            // We don't need to use the `this`
            Dependencies
            {
                Compile("Some code to compile") ;
                TestCompile("");
            };
        }.Run();
    }
}

Benefits

• support for custom DSL syntax
• improved readability
• support for the functional style programming
• LINQ can be used like DSL language
• endless possibilities to write extensions like also, with, apply, with
• basically allows to write won using with very similar syntax
• even the ; can be omitted to have experience like using
• with default name like it for the first lambda parameter, it shortens the syntax too

Shorthand Properties

This

class Foo
{
    public val Int Count;
    public var string Name;

    void Bar()
    {
        val string text = "";
        //o r
        val text2 = "";
        var Int length = 3; //common var
        // or
        var length2 = 4;

        text="4"; //throws exception - can't be changed - constant
    }
}

is adequate to the

class Foo
{
    public Int Count { get; set; }
    public string Name { get; }

    void Bar()
    {
        val string text = "";
        var Int length = 3;
    }
}

Benefits

• shorter syntax to the readonly
• can be combined with the primary constructor auto properties like class Foo(val Int Count)

Constants and Static Methods Can be Without Class

namespace Test
public const string Text = ""
public static void Foo() {}
public static void Bar<T>(this T what) {}

is equivalent to the

namespace Test
public class __Genretated_1
{
    public const string Text = ""
    public static void Foo() {}
    public static void Bar<T>(this T what) {}
}

usage:

using Test;

print(Text);
print("".Bar())

or

print(Test.Text)

Benefits

• shorter syntax
• no need to introduce wrapper/bearer classes without meaning

[333fred]

Duplicate of dotnet/csharplang#9951, but posted by a different person in the wrong repo.