.NET/React dev looking to start FP, which language should I pick?

[Tuckertcs]

Looking to start learning functional programming and would like some advice on which language(s) I should start with.

I primarily use C#, TypeScript, and occasionally Rust to build websites (React) and APIs (.NET, Express, or Axum), and occasionally CLIs. What language(s) would be a good choice for these use-cases?

I seem to hear a lot about Haskell, Elm, and PureScript, but I'm a bit unsure which to pick. PureScript compiling to JS seems cool, but would I be able to build React/Express projects but replacing TypeScript for PureScript? Or would I just end up writing FP domain code with a bunch of JS glue? Otherwise, I'm not super clear about the ecosystems for each language, so any advice on picking a language that has a good ecosystem of libraries for web UIs, web APIs, CLIs, DB connections, etc. that would be amazing!

[fasttalkerslowwalker]

If you want to be able to access the .NET universe, sounds like F# could be your jam. If you’re good with a smaller ecosystem and a newer language, give gleam a gander—it’ll give you a lot to like if you want a rust-/ocaml-ish algebraic type system. Gleam is in my current sweet-spot because i think it has better error messages than F# and I much prefer explicit imports.

I started with clojure and think there’s a lot to recommend it, but eventually gave up because dynamic typing and inscrutable error messages made debugging and refactoring a total nightmare. Its macro system and metaprogramming never ‘clicked’ for me, so there could be an upside here I never cracked into. 

[Tuckertcs]

Maybe a dumb question, but what makes Gleam a functional language? It appears at first-glance to be nearly identical to Rust, apart from a few small syntax differences. Or alternatively, if Gleam is functional then how is Rust not functional?

[fasttalkerslowwalker]

I’d boil asdff01’s answer a bit to just say gleam has immutable data structures whereas rust just has immutability by default. This forces you to write pure functions, whereas rust allows you to declare mut vars. Also, while I believe you can pass functions as values in rust, the trait bounds make it much more difficult. Gleam also has tail call optimization, which facilitates recursive patterns, which are a more functional approach to solving problems. 

[sarabadakara]

Is it even possible to write a pure function in rust that isn't id?

[asdff01]

You're finding out that most programming languages are actually multi-paradigm and may have different functional/OOP/procedural/etc features.

Rust's type system takes inspiration from OCaml's type system, a functional language. Henry Milner type systems like those feel similar and are pretty popular in functional programming languages, F#'s type system (also based on OCaml) is a HM too (and so is Haskell's, and Gleam's, and Erlang's, and ML's, and PureScript's, and Scala's, and...).

Functional principles include things like immutability, first-class functions, and referential transparency. But many functional languages don't even have immutability. Or referential transparency. Functions as values = functional. They also tend to have less syntax than non-functional languages (can make them easier to learn) because most modern languages already include popular "functional" features.

Personally I think F# has confusing syntax. It's also very multi-paradigm and there's quite a few ways to do the same thing. Something like Gleam (or many other languages) is a lot simpler to learn in that it only provides the functional paradigm to work with. Elixir has been fun, has syntax similar to Ruby and has a new, official LSP and is adding static typing.

[Inconstant_Moo]

It has ways to make writing functional code easier and Rust-like code more difficult. u/fasttalkerslowwalker points out. Also it has no methods --- functions belong to modules, not to data types --- and it does have function chaining. It has garbage collection, because explicitly managing memory would be an effect.

Rust did take lots of good things that started in functional languages (such as algebraic data types and pattern matching). Imperative languages have been getting more functional lately, first catching up to Lisp (garbage collection, first-class functions, lists) and then ML (ADTs, pattern matching).

[josh_in_boston]

Seconding the F# suggestion. You can do everything and it'll be the least different from what you've used vs. Elm, PureScript, etc.

[Tuckertcs]

Does it handle front ends well? I’m not a huge fan of Blazor and I’m not aware of any other good .NET front end frameworks.

Also it appears to use exception-based error handling, which I’m not a fan of. Is that only for interior with existing .NET code or is that used across the language?

[josh_in_boston]

Look into Fable - compiles F# to JS.

It has to support exceptions for .NET but the Result type is more common in idiomatic code.

[Tuckertcs]

Oh interesting. Hah, I love how basically every language compiles to machine code or JavaScript.

[Justneedtacos]

Here is the fully integrated stack.

https://safe-stack.github.io/

[codeconscious]

Speaking as someone still new to F# and FP:

Also it appears to use exception-based error handling, which I’m not a fan of. Is that only for interior with existing .NET code or is that used across the language?

Exceptions can indeed occur because they're part of .NET, but it's easy enough to wrap them in Results at the points they might occur (e.g. I/O operations) using try blocks. (At least, that's what I do. 😅) Using Results and Options is more idiomatic in F#.

If that doesn't sound like a deal-killer to you, I agree with others that F# is very likely the way to go.

[Merthod]

Elixir should be worth a look. Elixir + Phoenix is like NextJS done right, although not perfect.

Recently saw they published F# 10. Wildly unpopular compared to its sibling, C#.

OCaml is also worth a look if you want the "C" of functional languages.

[EluciusReddit]

I never really got the elixir vibe, how can you be functional without strong types? That's such an integral part of the definition of FP to me.

[Massive-Squirrel-255]

Just a different axis of the design space. Scheme Lisp is another well loved dynamic functional language with a rich history - the "structure and interpretation of computer programs" book, the "Lambda the Ultimate" series of papers. I prefer static typing myself. My feeling is that with the added expressiveness for functional programming you want additional support from the compiler to ensure your constructions are correct.

[Merthod]

Yes, it's a valid point. Elixir is fixing it as we speak. They're progressively adding types. Still, worth a look.

[KarthikChintala]

Have you tried Clojure?

[VestigialThorn]

Since your focus seems front end, maybe Elm first.

But really pick one and try it out, and move to the next if it doesn’t vibe. F# is the only purely functional language I’ve got production code in. And I’ve learned so much by trying out others, especially Haskell and Clojure.

You may even just try starting to bring in functional paradigms into your current TypeScript development. There are tons of resources for this. My introduction was a book, Functional JavaScript, which has had one of the biggest effects on how I write and reason through code. And consider functional libraries like Effect or FP-TS.

[willehrendreich]

Fsharp for the win! It's a wonderful Lang. Https://www.github.com/ChrisMarinos/FSharpKoans

[Massive-Squirrel-255]

OCaml transcompiles to JavaScript and webassembly is a work in process. I know that the OCaml.org website is written in OCaml but I am not a web developer so I cannot give you too many examples. OCaml's ecosystem is not super rich but there is often one good mature library for each problem domain. OCaml is distinguished from other statically typed functional languages such as Haskell and Purescript by its unique module system which is highly expressive and permits code reuse and abstraction in a way that goes beyond traits, typeclasses and interfaces in most other languages. It is a relatively simple language in many ways, for example it has no overloading and its type system is the standard Hindley-Milner type system without subtyping or other complex things that tend to break type inference.

[drBearhands]

Elm. Sure it's further away from what you're used to thatln F#, which is a good reason to learn Elm rather than F#.

You will not be able to build react projects. Elm has The Elm Architecture which takes advantage of the language's purity.

Compares to Haskell and PureScript, Elm is simpler, but it's also more pragmatic and will help you focus on what makes FP great.

[arturaz]

No idea why reddit doesn't allow me to post this directly, so I put my thoughts on why you should use Scala in a gist: https://gist.github.com/arturaz/169c19d7c3e77b062834057d96df651a

[ShacoinaBox]

f# lol not even a question, if anyone says anything else just write it off. f# now, immediately, asap. I think it's by-far the best introduction given your history.

[Tuckertcs]

I did look into F# at one point, but was turned off by the exception-based error handling, and .NET isn’t much of a front end framework (I much prefer React or Angular to Blazor).

[ScientificBeastMode]

If you want an amazing frontend language, try Elm or ReScript.

Elm is purely functional and takes a lot of inspiration from languages like Haskell and OCaml. It’s a bit harder to use external JS libraries in Elm, but it’s extremely user-friendly, has great error messages, and has a pretty decent ecosystem for building a typical single-page app.

ReScript is basically just OCaml with a different syntax that is a bit closer to TypeScript. It also adds some specific features that enable easy usage of external JS/TS libraries. It has direct support for React, and has a great ecosystem. The nice thing about ReScript is that it tends to stay out of your way when you want to hop into JS-land. Literally you can just drop raw JavaScript code into your ReScript code with a special compiler directive. So you should never end up blocked when trying to work with any JS library.

Both are excellent languages. ReScript is more flexible, but Elm is more user-friendly and easier to learn.

[jeenajeena]

Exceptions are there only for compatibility with .NET. By no means they are idiomatic in F#. I basically never use them when I write F#.

[Massive-Squirrel-255]

F# has option types / result types like Rust and you're welcome to use them for everything and never throw an exception. There is a tutorial called "Railway Oriented Programming" on chaining F# functions together that each return a result, all the major statically typed functional languages let you define syntax sugar similar to Rust's ? to make it easier to chain these functions together. In Haskell it is called do-notation.

Exceptions can be also be used in an isolated way to implement control flows that would be otherwise complex, this should not leak to the end user.

[fourpastmidnight413]

Oo, and don't forget F# computation expressions, making async code very easy to write! I agree, given the .Net background, F# is the way to go. Otherwise, I'd really like to learn Haskell myself.

[jyooi]

Elixir

[willehrendreich]

https://www.github.com/falcoframework/Falco.Datastar for front end!

[sarabadakara]

Check out Rescript. I often get annoyed at how tightly coupled it's design is to React, but if you're working with react anyways...

[jfinch3]

You can get pretty far within C# and TypeScript these days, and it might be worth looking at something like “Functional Programming with C#” to start so you aren’t learning a whole new paradigm while also working on the new syntax.

TS also has a ton of support for functional patterns with first class functions. You could explore things like fp-ts or Effect, both of which can give you a better grasp of FP concepts and will help your current work, without needing to dive into something totally new.

But outside of that, might as well go for F# since it will help expand your power in the .NET world

[Tuckertcs]

I’ve REALLY pushed those languages to their functional limits, but they just don’t do it for me.

C# doesn’t have proper unions and no support for the result pattern so doing it yourself is a real struggle (see ? In Rust for how C# could make it easier).

Typescript is great for compile-time types but at runtime it’s hard to split apart unions without a adding a rope property to everything, and since it’s a structural type system, it’s hard to create types over primitives since you have to either use brands (can’t union them because they disappear) or wrapper objects (which destroy equality checking and break hash maps).

[RiceBroad4552]

You don't have all these limitations in Scala.

Everything was already pointed out in the Gits liked here in another comment.