Proposal: infix functions as pseudo custom operators with redundant brackets

[tomschrot]

Hello everybody

First, please excuse my bumpy English, Im not native English speaking.
After a 2 year excursion into the Kotlin universe, I ended up with good old C# and .NET CORE again. But there are some wistful memories that I really would like to see in C# that could make C# code more compact, less verbose and increase readability. One thing that I had come to appreciate in Kotlin is the ability to define infix functions that can be regarded as sort of custom pseudo operator. The rule is simple, just write a function that has one single parameter and declare it as "infix". Like with C# operator overloading, the brackets become obsolete. Example in standard C#:

`
class Program {

    static void Main(string[] args) {

        var a0 =
                new Container<int>( 1 )
                .alter ( x => x+1 )
                .use   ( x => Console.WriteLine(x) )
                .alter ( x => x*x )
                .use   ( x => Console.WriteLine(x) )
                .alter ( x => x*x )
                .use   ( x => Console.WriteLine(x) )
                ;
    }
}

public sealed class Container<T> {

    private T   item;
    public  T   value   { get => item; }

    public Container(T value) => this.item = value;

    public Container<T> alter (Func<T, T> fun) {
        item = fun(item);
        return this;
    }

    public Container<T> use (Action<T> act) {
        act(item);
        return this;
    }
}

`

Could become like this:

`
class Program {

    static void Main(string[] args) {
        var a0 =
                new Container<int>( 1 )
                .alter x => x+1
                .use   x => Console.WriteLine(x)
                .alter x => x*x
                .use   x => Console.WriteLine(x)
                .alter x => x*x
                .use   x => Console.WriteLine(x)
                ;

    }
}

public sealed class Container<T> {

    private T   item;
    public  T   value   { get => item; }

    public Container(T value) => this.item = value;

    public infix Container<T> alter (Func<T, T> fun) {
        item = fun(item);
        return this;
    }

    public infix Container<T> use (Action<T> act) {
        act(item);
        return this;
    }
}

`

I'm aware that the given example ist not the best one, but I think the idea is clear. (Read about custom operators here 4 Y ago, that should do it...)

It could also be great to adopt the Kotlin lambda notation, but this is another story!

What do you think?

[YairHalberstadt]

If you write

new Container<int>( 1 )
        .alter x => x
        .use   x => Console.WriteLine(x)

How can you tell if its:

new Container<int>( 1 )
        .alter(x => x)
        .use(x => Console.WriteLine(x))

Or

new Container<int>( 1 )
        .alter(x => x.use(x => Console.WriteLine(x)))

?

[333fred]

Did you perhaps mean to remove the dots from the second example? It still has ambiguities though, as Yair pointed out.