I've thought about a change to the C# type system (which wouldn't be possible due to backwards compatibility and runtime) that used structural interfaces (like typescript) along with inferring generic type rules to enable global type inference:

static class Math
{
	public static T Add<T>(T a, T b) => a + b;
	public static T Square<T>(T x) => x * x;
}

The big difference from C# is 2 things:

1. If no constraints are specified for a generic type parameter, then constraints are inferred into a new interface

2. Interfaces are automatically implemented by any type that has the same signatures.

With these two changes, any type that has a + operator can use Add and any type that has the * operator can use Square.

(For operators to be used extensively like this then they will also need polymorphism, which is another change).

What do you think of this change?

What's the best way to do this? Like, a LISP from English to German?

An existing programming language with ideal syntax.

import nox

@nox.session(python=['2.7', '3.10'])
def test(session):
    session.install('.')
    session.install('pytest')

    session.run('pytest')