elmish VS Giraffe

For those interested in .NET languages with alternative compilation targets, Elmish (https://elmish.github.io/elmish/) is pretty unique.

We use F# on the front end (instead of TS), and thanks to the Fable compiler (which transpiles F# to JS, Python, Dart, PHP and Rust), most of the benefits of an Elm-style model in the UI can be ported to all sorts of different outputs languages. The rust target is in beta, but its promising because the WASM bundle size stands to be dramatically lower.

While the default is reactivity library for Elmish is React, you can swap in Avalonia/FuncUI (https://github.com/fsprojects/Avalonia.FuncUI) pretty easily as well.

Naturally I’d recommend using a better language such as ReScript or Elm or PureScript or F#‘s Fable + Elmish, but “React” is the king right now and people perceive TypeScript as “less risky” for jobs/hiring, so here we are.

Since you're familiar with React + Reframe, you can try Elmish! You can use F# to write [Elmish](https://elmish.github.io/elmish/) apps. It takes the Elm approach to building apps.

Who’s paying for this? https://github.com/elmish/elmish

Try F# with Elmish.

Maybe elmish could be of interest to you? https://github.com/elmish/elmish

I never tried Elm directly, but I have used the F# equivalent Elmish - super productive idea.

You can also get nested templates, bind inputs, and radios for example by the way don't be scared by the mutable keyword right there is just to show a brief example in a normal situation you would likely be using Elmish

Comet promotes a variation of the Model-View-Update pattern popularized by The Elm Architecture, Elmish, Fabulous and others. The major parts of MVU are:

Giraffe is another interesting one to explore: https://giraffe.wiki/

Giraffe is nice because it is itself built "just" as ASP.NET Core Middleware so it plays a bit more nicely than Suave with a mixed stack of C#-defined Middleware.

It's more likely you accidentally fall back into just translating C# patterns to non-idiomatic F# with Giraffe, but it's also nicer when in that case of needing to live in both worlds and use a mixture of libraries built for C# ASP.NET projects.

There are also some F# frameworks built on top of ASP.NET core like https://giraffe.wiki

If you have an interest in F#, I highly recommend diving in because (1) it has a ton of things you might learn to appreciate in C#; (2) it has things C# cannot have. I do like some of the suggestions people have made regarding mixing your code bases, but I'll also say that building, say, endpoint routing in Giraffe is (to repeat myself) easy, simple, and elegant.

Bix is a micro-framework designed with F# in mind and that runs on both Deno and Bun! and in theory it also should even run in a service worker! (intercepting fetch requests) although I haven't tested that yet, it offers a general purpose handler that coupled with a set of route definitions it can bring a Giraffe/Saturn like framework to life in JavaScript runtimes which is incredibly awesome! useful? maybe not 😅, but awesome indeed. Let's see some code for it

Backend: Most likely it would be a toss between https://saturnframework.org or https://giraffe.wiki. They both combins the extremely good type system in F# combined with the ease of a minimal API.

I was wondering if its possible to simultaneously run a C# core MVC project in combination with https://github.com/giraffe-fsharp/Giraffe

By default Giraffe, the framework which I use as a web server, uses Newtonsoft.Json to serialize results to JSON. However, for discriminated union, it generates quite a lot of JSON so I've switched to System.Text.Json which is built into newer versions of .Net Core. In combination with FSharp.SystemTextJson package allows serializing discriminated unions more gracefully. All we need is to decorate Branch type with JsonFSharpConverter(JsonUnionEncoding.BareFieldlessTags) attribute.

Giraffe is a library that sits atop ASP.NET Core and allows developers to build web applications in a functional style; dotnet new giraffe is literally my starting point when I begin a new web application project. (Rather than write three more sentences filled with effusive praise, I’ll just leave it at that; it’s great.) It also provides a view engine (that builds upon Suave‘s “experimental” view engine) which uses an F# DSL to define HTML in a strongly-typed way. It has been incredibly efficient for a while, but with .NET’s work over the past two releases at improving performance, and Giraffe’s adoption of those techniques, it is lightning fast.

Wrapping ASP.NET Core to be easier and more idiomatic with F# seems to be a common domain. Out of curiosity, did you look at any existing projects? If so, what was lacking from them that made you decide to write WebFrame?

Giraffe: https://github.com/giraffe-fsharp/Giraffe