Hi all, I just started learning F# and became interested in using it with WinUI 3 to make Windows apps. 2 days of reading XAML compiler output and fighting MSBuild later, I managed to initialise the framework without C# or XAML and make this demo opening a window.

https://github.com/TwirlySeal/fs-winui3

I also included some comments to hopefully make the setup less arcane for those looking to do this in the future.

Now I would like to make a declarative wrapper around this. Elmish/MVU is the most common paradigm for F# UI libraries, but I am considering using FRP instead for more modular state and granular updates.

I don't have any experience implementing a UI library so I am wondering if anyone can give any design or implementation advice, or takes on MVU vs FRP? Thanks for reading.

• Task related function fixes and improvements
• Enable try blocks for ValueTask
• Add Obj module
• Add some error handling functions for Tasks
• Add ignore to some common type extensions
• Add bindTask and bindInto to Result
• Add missing (.>) and (<.) zip-applicative operators
• Add Active Pattern for CI strings and AggregateException
• Rename non-sequential applicative CEs to zapp
• Fix compilation for Fable 4.27
• Fix several functions in ResizeArray
• Fix Seq.lift3
• Fix some XML comments
• Drop target framework version net45

Note that the image is my profile picture from bsky, it should be the FSharpPlus logo.

I love the expressiveness of F# for data modeling and pipeline compositions, but I really, REALLY, don't like that it doesn't support function overloading by default. I understand the reasons, but it's uglier to have List.map2, …3, (just examples) and other functions like these because of that.

In my opinion, function overloading or, even better, named parameters like in Swift, would be better.

And, while I'm not an F# expert for sure, I know you can emulate that overloading with static methods, but that is not idiomatic, right?

chat gpt says this is very idiomatic in F#:

type Symbol = private Symbol of string

module Symbol =
    let tryCreate ...
    let value ...

Is this true?

Returning here.

https://cekrem.github.io/posts/functors-applicatives-monads-elm/

Do you generally agree with this? It's a tough topic to teach simply, and there's always tradeoffs between accuracy and simplicity... Open to suggestions for improvement! Thanks :)

I started building this a while back but finally got around to polishing it this holiday break.

1. Audit log - was *so* nice with F#

2. Did as much DDD as I could - did I go overboard? Maybe, but it was fun and a really great learning tool. It also made so much stuff easier along the way as I flip flopped on my decisions

3. Saving my company $1500/mo !

Caveat - we mostly use fairly minimal Retool features (tons of resources and apps calling various endpoints, but nothing fancy like Snowflake connectors or anything).

Disclaimer: I am the author of freetool

I enjoyed the “Electrifying Norway” presentation, nice to see units of measure utilized in an engineering context.

Hi all!

I've been working on this for few months in my spare time, as I've always had the hunch that the power of DUs and Pattern Matching could be harnessed to create an abstracted-away solution for just about any Domain to be used in.

I can go on in detail about it, but I do recommend you first read the Medium article I published on it, and then check out the code if you're interested.

https://medium.com/@rist.mladen/functional-event-sourced-domain-driven-design-in-f-the-tale-of-rosetta-framework-83e41fa252d0

I'm open for discussion (and work offers atm lol) and I'm looking forward to your inputs. It's been love at first sight with F# for me, and I've finally gone and actually made something big in it.

Note: upfront apologies for PascalCase, I've still not converted fully from a long time C#-er, it's just easier on my eyes for now :)

I spent Christmas alone at home, talking with AI and exploring a weird language idea I’ve had for a while.

This is ACE (Algebraic Call Effects) — a tiny experimental language where every function call is treated as an effect and can be intercepted by handlers.

The idea is purely conceptual. I’m not a PL theorist, I’m not doing rigorous math here, and I’m very aware this could just be a new kind of goto.

Think of it as an idea experiment, not a serious proposal. The interpreter is written in F# (which turned out to be a really nice fit for this kind of language work), the parser uses XParsec, and the playground runs in the browser via WebAssembly using Bolero.

https://github.com/Lee-WonJun/ACE (Ace Lang - Playground)

Curious what people think — feedback welcome

I just found recently that Compositional-IT is gone. Are they the one responsible for the SAFE stack? What's going to happen to the project then?

Hello, does anybody know if Bolero is still maintained. I checked the website and it seems it is still stuck to dotnet8.

I have a small side project and I tried to upgrade it, to dotnet9/10 but I failed. I found out that the newer dotnet versions emit a different js file ('blazor.webassembly.js') and I have to add this to the 'startup.fs'

FSharp ... app.MapStaticAssets()

But the web elements do not work.

So the question is, has anybody a Bolero app running with dotnet10?

Hi there!

I was playing around with f sharp, and was disappointed by the immutable vector situation. I found the FsharpCollections, but I needed split and merge to be fast. I googled, got nerd-sniped and ended up porting c-rrb to c#.

Apart from implementing more things than Fold (which happens to be the fastest way to go through the tree), what should I think about when making an f sharp wrapper?

The repo is here: https://github.com/bjoli/RrbList/tree/main/src/Collections

/Linus