This was also my experience with F#, phenomenal language dragged down by ugly interop with an ecosystem that barely acknowledges its existence and I feel is incompatible with its ideals.
Shame too because there’s some genuinely great stuff in the community like fable [1] where if you were to chuck in JSX like templating you’d have an absolute killer web tool rather than the mess blazor is.
It’s ironic that I found js interop less annoying than .net interop.
> At the end I went with Rust because it has one way of doing such stuff.
I haven't looked at C# in 20 years, but Rust certainly has a LOT of ways to do similar things too:
struct Foo { x: f64, y: f64 } // Struct
struct Foo(f64, f64) // Tuple Struct
let f = (1.0, 2.0) // Tuple
enum U { Foo(f64, f64) } // Enum Tuple
enum V { Foo { x: f64, y: f64 } } // Enum Struct
[ 1.0, 2.0 ] // Size-2 Array
&[ 1.0, 2.0 ] // Slice
vec![1.0, 2.0] // Vec
Anyways, I haven't used Rust in a few years now either, and I'm sure I've made some mistakes and omissions above, but I don't remember it as the poster child for Python's "There should be one-- and preferably only one --obvious way to do it".
I don't know, I'm not too bothered by this. If you take struct tuple and struct, Yes synctacticqlly they are different but functionally they are quite similar. You have values lying in memory. There's no reason to prefer one to the other except convenience. Program behaviour will not change. This is not the the case for fsharp classes and records and structs. Same way Fsharp has two types of lists. It also has an array type and all these are different but they look the same. In rust case they all have different names but behaviour wise they are same: data stored in contiguous memory with some differences in what you can do with them. I do like fsharp as a language but it can't go full on its promises because of dotnet. One glaring one is nulls. The language itself claims to be null safe. Except if you use dotnet types like strings. Then the compiler doesn't warn you. Honestly Kotlin does this better with non nullable types and null chaining
If you think of using C# libraries from F# as comparable to using other people's crates in Rust, you're going to get exposed to other people's choices for data structures in both.
For example, an array and a tuple are both aggregate types, but arrays store multiple value of a single type, and tuples store multiple values of the same type.
Some of these do boil down to “named or anonymous” but that’s also two different things.
There are a lot of almost orthogonal features one might choose for a record type:
Accessor: rec.x, rec.0, rec[0], match
Constant vs Mutable
Reference vs Value
Nominal vs Structural/Anonymous typing
Subtyping for inheritance
Subtyping for sum/union types
And more depending on the language (ownership in Rust)
> tuples store multiple values of the same type.
I'm sure this was a typo. :-)
I’m not trying to pass judgement on C#. I just don’t see a lot of these things as being that similar to each other.
As for only needing them when you need them, how could it be otherwise? :-)
The thoughtful, but not breakneck speed of changes within the language is one thing I appreciate a lot. Things do get added (there are proposals and discussions that are fairly regular in the GitHub repo for language design matters). A recent example is adding a spread operator.
In practice, this ends up being mostly simple to deal with.
In the other direction, consuming C# libraries historically hasn't had too much trouble other than they don't really design them with any functional-leaning in mind. The real problem that's growing recently is the dotnet teams move towards C#-centric features. Things like source-generators, roslyn, etc that are "C# features" and not "dotnet features". These types of things could create a big enough rift to break practical usage of F# as a dotnet interoping language if it goes unchecked.
Records have built in equality logic, Classes don't.
And, because of the interop story, they wanted to be able to define classes.
> C# reified generics and rust like monomorphised generics (with inline keyword) and they used to have two different syntaxes until recently
I almost prefer the old way, where SRTPs required the other syntax. On the other hand I guess between 'inline' and constraints the compiler makes the 'best choice' now...
Also, just minor pedantic comment, both C# and F# will monomorphize for struct of T
I'm aware of this but i feel this is confusing. Just putting () changes semantics a whole lot
> Also, just minor pedantic comment, both C# and F# will monomorphize for struct of T
I wasn't aware thanks
Dotnet does have some minor annoyances (exceptions being one) but gives the ability to deploy everywhere, GUI apps on all platforms, web, backend is fantastic. Lack of native GUI apps would be the main deficiency for me from Gleam, plus the fact that they have decided their community is explicitly politically woke-liberal.
Rust has been a fantastic addition to the language ecosystem, but recursive types, which are the bread and butter of ML-family code, are just too hard to write in Rust.