csharplang VS language-ext

Certain parts of Microsoft Learn are permissive, for example the .NET BCL documentation is Creative Commons Attribution: https://github.com/dotnet/dotnet-api-docs as is ASP.NET Core: https://github.com/dotnet/AspNetCore.Docs (a good hint if documentation is permissively licensed and on GitHub is if there's an edit button at the top.)

The C# language specification is unfortunately a bit fuzzier: https://github.com/dotnet/csharplang/discussions/4855

The updated unified C# language specification is CC, but it's still catching up to modern C#: https://github.com/dotnet/csharpstandard

No OP, but for example you still see the C# folks still struggling to add discriminated unions to the language because of complex interactions due to its too many features[1]. Virtual threads are easier to use than async/await is another example.

[1] https://github.com/dotnet/csharplang/issues/113

For example, C# had a research fork called Spec# that had compile-time support for contracts, with keywords such as requires (for arguments) and ensures (for return values), all the way back in 2004. While still being discussed, it doesn't seem to be shipping any time soon.

Hi there. I'm the language designer who created the 'Collection Expression' design/specification: https://github.com/dotnet/csharplang/issues/5354

You can see the entire history of the proposal there. To answer you specific question, we went with `..` because that's what the language already uses for the complimentary 'pattern matching deconstruction' form for collection patterns.

In other words, you can already say this today:

    if (x is [var start, .. var middle, .. var end]) { ... }

You must specify concrete type.

There was a plan to have "natural type" so "var list = [1,2,3]" would be of type "List" but it was postponed to C# 13 (https://github.com/dotnet/csharplang/issues/5354#issuecommen...)

While C# currently lacks direct support for this kind of functionality, there's a glimmer of hope with an active proposal under discussion that aims to bring this feature to the language. This potential addition promises a future where C# can natively offer similar robust type narrowing.

Given few people anticipated ValueTuple and C# adding a more direct tuple syntax, I feel like it is only a matter of time before C# adds discriminated unions.

(There are multiple proposals tracking the idea. This seems the most comprehensive and "central": https://github.com/dotnet/csharplang/issues/7016)

I always liked list abbreviations in python, but I absolutely love Linq. I believe there is a feature proposal for C# 12, which makes collection initialization better imo.

You probably noticed that .SetName() returns a Either. You may have come across Unit in libraries like MediatR or Language-Ext. It's a simple construct representing a type with only one possible value. We use it as a placeholder for operations that do not return a value but may return another state. In our example, .SetName() is a Command that does not return a value but may fail. Therefore, the monad Either carries two possible states: Right (without value) or Left (with an Error).

Language-Ext is my personal favourite, but it can be a bit overwhelming for beginners due to its extensive feature set

> but I just want something closer to Scala, but for .Net

That's what I'm working toward with my language-ext library [1]. Obviously more support for expression based programming would be welcome (and higher kinds), but you can do a lot with LINQ and a good integrated library surface.

[1] https://github.com/louthy/language-ext

Definitely a fan of option types, I wonder this library has anything over the C# library language-ext which also has an Option type?

Hey, I am considering adopting the Result pattern in my codebase. Wanted to get some opinions from someone who has experience with it: should I start with language-ext or FunctionalExtensions?

> [1] https://github.com/louthy/language-ext

Cool library. I've had a few of these patterns in my Sasa library for years, but you've taken it to the Haskell extreme! Probably further than most C# developers could stomach. ;-)

You might be interested in checking out the hash array mapped trie from Sasa [1]. It cleverly exploits the CLR's reified generics to unbox the trie at various levels which ends up saving quite a bit of space and indirections, so it performs almost on par with the mutable dictionary.

I had an earlier version that used an outer struct to ensure it's never null, similar to how your collections seem to work, but switched to classes to make it more idiomatic in C#.

I recently started sketching out a Haskell-like generic "Deriving" source generator, contrasted with your domain-specific piecemeal approach, ie. [Record], [Reader], etc. Did you ever try that approach?

[1] https://sourceforge.net/p/sasa/code/ci/default/tree/Sasa.Col...

[2] https://sourceforge.net/p/sasa/code/ci/57417faec5ed442224a0f...

languageext supports linq for its monads and I kinda love it. The challenge is convincing my colleagues. 😅

language-ext supports it and it's pretty dang cool.

I can only recommend c# language extensions library https://github.com/louthy/language-ext