Make C# maths stuff look like maths

[CPosingies]

Hello fellow coders,

since this is my very first language proposal, please be patient and kind. By the way, I guess my C# language skills may be better than my English language skills... :-)

Still, am I the only one who's suffering from a lack of freedom in naming fields and operators? The best thing regarding code within the last few days was finding out that greek letters are perfectly valid variable names, thanks to copilot, yessss!

Now, greedy as I am, look at a line of code (written in a fluent'ish style for a reason) like:
if (alpha.isIn.Range.From(0).Inclusive.To(Math.Pi).Exclusive ...
Compare to:
if (α ∈ [0 .. π[) ...

Imagine a library's method like MyMathLib.Gradient(MyMathLib.ParametricVector<Func<T, T>, Func<T, T>, Func<T, T>>). The issue that the shipped libs seem to lack such a type (a parametric vector) doesn't matter at the moment. Instead, imagine:
var v = new ParametricVector<double>(Math.Sin, Math.Cos, t => t);
and then:
var r = ∇v;

I know, this is like opening Pandora's Box because... Shouldn't vectors be decorated with a harpoon, or set in italics or in bolds? What about indices?

Perhaps I am the only one who'd love to see such possibilities, but think of code in the AI context where maths are getting more and more complex, and the domain's topics are moving from coders to (also) mathematicians.

[huoyaoyuan]

The symbolic language used for math itself is ... not so consistent. Different advanced areas define different simplified forms, which may not be always compatible or distinguishable.

By the way, I guess my C# language skills may be better than my English language skills... :-)

I'm also a non-English speaker. In my view, the "fluent" English words are quite not readable.

However, I do consider the OOP syntax with operators are readable. It's clear about what operations to do, or what semantic to achieve.

Now, greedy as I am, look at a line of code (written in a fluent'ish style for a reason) like:
if (alpha.isIn.Range.From(0).Inclusive.To(Math.Pi).Exclusive ...
Compare to:
if (α ∈ [0 .. π[) ...

The C#-ish expression is if (α is >= 0 and < π). It's a little more verbose than mathematical range, but even clearer for novice math learners.
α and π are already valid identifiers. You can define such a helper then π will be globally available:

global using static GlobalConstants;

public static class GlobalConstants
{
    public const double π = Math.PI;
}

Imagine a library's method like MyMathLib.Gradient(MyMathLib.ParametricVector<Func<T, T>, Func<T, T>, Func<T, T>>). The issue that the shipped libs seem to lack such a type (a parametric vector) doesn't matter at the moment. Instead, imagine:
var v = new ParametricVector<double>(Math.Sin, Math.Cos, t => t);
and then:
var r = ∇v;

This requires custom prefix-operator support (#3172). But in real world, people will definitely define helper functions for common operations like Laplace Operator. The delegate-oriented form in the example won't be used in real-world, because it would be much worse than SIMD-optimized operators.

Shouldn't vectors be decorated with a harpoon, or set in italics or in bolds? What about indices?

The story is different in handwriting/printing and computer typing. In computer we tend to make names longer because the tooling can fill the name. With (extended) Hungarian naming convention, it becomes vec1 etc for vectors.
Using variations of letters was discussed in #1742 (comment) and #3490.

[CPosingies]

The symbolic language used for math itself is ... not so consistent.
Well, actually it is. While in some countries somebody would use a quarter circle to mark a rect-angle, in other countries they use something more rectangular... not ment to be as a pun. still, if you argue like that, we could also argue over Arabic numerals like 1, 2, and 3 versus Chinese numerals 一, 二, and 三,

However, I do consider the OOP syntax with operators are readable. It's clear about what operations to do, or what semantic to achieve.

Now, greedy as I am, look at a line of code (written in a fluent'ish style for a reason) like:
if (alpha.isIn.Range.From(0).Inclusive.To(Math.Pi).Exclusive ...
Compare to:
if (α ∈ [0 .. π[) ...

The C#-ish expression is if (α is >= 0 and < π).
Well, in fact it's
if (α >0 && α < π)

Just to mention, I don't want to CHANGE the current syntax, I want to add these variants, yes, as syntactical sugar. To make my most beloved programming language even more attractive for scientistic purpouses. Nobody should be forced to use such grammar/syntactical annotation.

It's a little more verbose than mathematical range, but even clearer for novice math learners.
Absolutely, but novices won't use Lambdas either, nor would they use well-known (to us at least) software practises, patterns, architectural stuff. And they don't have to. I don't want to remove * in 2 * 3 = 6, I just want to be able to write 2 • 3 = 6, and I want to be able to write
static public double operator √(double operand) { ... }

Imagine a library's method like MyMathLib.Gradient(MyMathLib.ParametricVector<Func<T, T>, Func<T, T>, Func<T, T>>). The issue that the shipped libs seem to lack such a type (a parametric vector) doesn't matter at the moment. Instead, imagine:
var v = new ParametricVector<double>(Math.Sin, Math.Cos, t => t);
and then:
var r = ∇v;

This requires custom prefix-operator support (#3172). But in real world, people will definitely define helper functions for common operations like Laplace Operator. The delegate-oriented form in the example won't be used in real-world, because it would be much worse than SIMD-optimized operators.
Actual implementations sould be open for a race. I am absolutely aware of the fact that speed will be even more mandatory in the future. Again, it's about syntactical sugar to distinguish arbitrary languages like python from more advanced languages like C#. And to draw more scientists than game developers.

The story is different in handwriting/printing and computer typing. In computer we tend to make names longer because the tooling can fill the name. With (extended) Hungarian naming convention
Well, at least I am happy to have become beyond the "psz_fh0" world. I don't care about Hungarian notation, but I am am the first to call to readability, like "Win32HandleToTheMainWindow" if it must be, else I'd prefer "MainWindow", without any p, s, z ado. If it's readable, it's readable. If it's obfuscated by itself, it's rubbish.

Still, I'll keep on it: If it's maths, it'd look like maths.

[koszeggy]

if (alpha.IsIn.Range.From(0).Inclusive.To(Math.Pi).Exclusive

<‍irony>I actually find this more readable. 😀 In my eyes, mathematicians are like programmers with poor coding standards. They tend to use non-descriptive ultra short variable and constant names, preferably single letters. If they run out letters, they start to use the Greek/Hebrew/gothic alphabet or accents/strokes rather than starting to use descriptive variable names. 😂<‍/irony>

[jnm2]

When I see if (α ∈ [0 .. π[) ..., I see a second minilanguage inside a language. This does not feel like C#. What's worse, the minilanguage seems to open us up to tons of ambiguities. I now have to learn a whole new set of rules to keep in mind any time I see [: it might be closing a prior construct instead of starting a new construct.

[BlinD-HuNTeR]

I suppose an in operator would be a fine addition to the language, other languages already have it, and it's very intuitive to write if (item in collection). It would also fit the role of this ∈ operator.

As for the implementation, it could bind to a Contains method in the target object, either instance or extension method, that takes an item and returns a bool. And maybe, if not found, it could use the Enumerator pattern, and fallback to an invisible foreach loop, that breaks when the item is found.

And finally, I guess it would be nice if it also supported collection expressions directly, such that you could write if (a in [1, 2, 3]), and it would be the same as if (a is 1 or 2 or 3).