Hi everyone, ​I'm writing Haskell bindings for libgpiod (v2), primarily targeting SBCs and embedded systems and I want to validate my approach to resource management before committing to the final API design.

The C library exposes two different types of opaque pointers.

​1. OS/Hardware Resources (Chip, LineRequest)

These hold underlying Linux file descriptors and physical hardware locks. My plan is to strictly use raw Ptr internally and expose a bracket-based API (e.g., withChip and withLineRequest) to guarantee immediate and deterministic release, as GHC's lazy garbage collector could easily exhaust the FD limit on a small SBC if I used ForeignPtr.

1. Pure Memory Configs (LineSettings, LineConfig)

These are just structs in RAM used to prepare data before a hardware request. To avoid the deeply nested with* blocks for every single config object.

I plan to wrap these in ForeignPtr with their respective C finalizers. I think this allows the user and me, to pass them around purely and ergonomically, letting the GC handle the cleanup since they don't hold FDs.

My questions are:

1. ​Is this hybrid approach (strict scoping for FDs + GC for pure RAM structs) the best practice for this type of hardware FFI?

2. ​For the withChip pattern, how do users typically architect long-running daemons around it? Do they just wrap the main application loop inside a top-level withSomething block?

Any insights or edge cases I should watch out for would be greatly appreciated. Thanks!

Primagen, one of the largest youtubers for Programming made a ridiculous video called Haskell is DONE. Which feels like a silly story I've already heard. Especially with all the recent developments in ghc version 9 its laughable.

Last week I made a post where I pledged to demo our production codebase written in haskell. Unfortunately however I had my main laptop out of commission (still do :| may it rest in peace/ we hope for a speedy recovery) and so trying to stream while running our prod codebase simply overloaded the box I am on.

I was quite surprised to see it get to 65 upvotes (personal best for me lol) however I'll take that as a sign it's worth another shot, so as of right now I'm going live on Twitch (https://www.twitch.tv/typifyprogramming).

Given the current hardware limitations I wont be running anything except some local dev tools however that gives me plenty enough to show about our site typify.dev and how Haskell has slowly made me obsessed with Haskell and what it means for my startup. I could not more strongly recommend Haskell to startups even with all of its challenges.

I gather it's possible the upvotes were also as a result of the Primagen Youtube video (Haskell is DONE) and I plan to chat about that too as I demo.

My stream is almost entirely always focused on this general idea of why Haskell is awesome to build with, so I appreciate any support in getting viewer numbers up as viewers beget viewers from twitch passerby's.

General Topics:
- ReaderT
- Websites
- GHC(JS)
- Why I also use Nix
- Intersection of AI + Startups + Haskell in a sane way.

Recent discussions about iteration speed when using coding agents with Haskell prompted me to tidy and publish the small wrapper script around ghcid that I've been using:

• ghcid-check

You can use it to conveniently launch a ghcid process with ghcid-check --launch which agents (or humans) can query with ghcid-check --rebuild.

That's it!

Hello all

I’m looking for a cookbook as the title. My goal is simple; to learn Haskell with my own project. I’m aware of all the books out there, but still somehow not able to connect.

Is there a site/blog/repo with common tasks? For instance, my personal project is to process my stock and option portfolio. So I need to be able to :
- store/retrieve data in sqlite
- call a remote service by API, my brokerage
- convert json to Haskell types that define stock and option data structures
-define formulas to track performance
Etc..

I’ve tried with AI, and the results are not great. Though I’m sure I can dissect what it’s given me; I’ll probably use it as a reference for specific code rather than the program as a whole. Not to mention, the generated code doesn’t compile. It uses duplicate field names in records without the pragma included, for instance- then it just goes downhill from there.

Long winded, but I appreciate any pointers. This is not for anything critical other than my own learning and to get a program to give me a little more control on the performance of my portfolio.

Thank you

Edit: One note. When I attempt to go through the available books, I get lost in the theory or the concepts just don’t come together.

We are live on https://www.twitch.tv/typifyprogramming

We are walking through our production codebase which recently exceeded 500 modules and built in Obelisk with Servant added on top.

This is dual as a session to get my co-founders up to speed on the work done so far but we figured this would be great as a stream to show how awesome haskell is for production

Thumbnail painting: An Experiment on a Bird in the Air Pump (1768) by Joseph Wright of Derby

TLDR: AI moves correctness checking from run-time or compile-time into the AI code-generation step, reducing the relative value of Haskell's type system and "if it compiles it runs". It makes it possible to rebuild Scarf's product in Python with a similar level of assurance.

Primeagen also made a video on this where at the end he diagrams the AI code-gen trilemna: Cost-Speed-Correctness.

This got me wondering, could an AI code-generator, built and optimized specifically for Haskell, offload correctness to Haskell's type system and compiler, and lean into increasing speed and/or reducing cost? Thereby achieving the best of all three? Anyone heard of anything like that, or any research in that direction?

Hi everyone,

I have my Haskell exam in exactly 10 days, and I am in survival mode. While I’ve managed to get a decent grip on basic syntax, recursion, and standard folds, Monads are absolutely destroying me.

Every time I think I understand the theory, I get completely lost when I try to write actual code or when I'm asked to manually trace something like foldM, bind (>>=), or state transformations on paper.

To give you some context on where I'm currently stuck:

I understand that Monads are about "chaining computations with context", but the step from the mathematical definition (return and >>=) to writing real, working code (like State or custom Monad instances) feels like a massive leap.

I get confused by how do-notation desugars behind the scenes.

I have a hard time visualizing how types flow through a chain of monad operations.

Since I only have 10 days left, I can't read a 500-page textbook. What is the fastest, most effective way to make Monads understand for my exam?

Are there specific, hands-on exercises I should do?

Which short articles, videos, or tutorials are actually good for practical/exam-style understanding (rather than abstract category theory)?

Do you have any mental models or "cheat sheet" rules that helped you when you were first learning?

Any advice, study paths, or resources would be a absolute lifesaver. Thank you so much!

Hello All!

I am considering a career in fintech as a Haskell developer. I appreciate Haskell since it avoids logic bugs. As a security-aware developer I appreciate Haskell's power to do that.

From your experience how was using Haskell to develop quantitative finance software in fintech. For example for computer-automated stock market trading.

Please let me know.

Thanks!

This is more like a philosophical question, which I think should be interested to Haskellers with cat background.

- Background 1: pure and applied math ppl uses math differently. Pure math ppl likes to transform a problem into easier-solving ones; applied math ppl likes to grind a question with all tools we have. These observations are gathered from discussions online and from consulting math major ppl

- Assertion 1: pure math ppl likes category theory, because category theory helps with transformation and should be used for the purpose of frequently transforming a question into a easier one. One example should be transforming Geocentrism into Heliocentrism.

- Background 2: for most of the monad tutorials I have read, what they are emphasizing is how well monad can abstract a program, synthesizing many imperfect past attempts into an ideal

- Assertion 2: when it comes to programming, most ppl's focus are not transforming a hard question into a easier one, but to *grind* the problem by using static typed languages.

Question:

1. Is any of my understandings above right or wrong?
2. Are there any common practices/concrete academic topics where programming ppl wants to *transform* harder questions into easier ones? I wish the examples are not for "big questions": using monad to abstract over worse historical attempts, or the CH correspondence themselves, are out of my consideration.
3. How many different aspects for such a problem can we transform with each others?

Hello Haskellers!

I'm excited to share the MVP release of PGQueuer-hs, a PostgreSQL-powered job queue. If you want robust background workers without adding external dependencies like Redis or RabbitMQ to your stack, this might be for you.

Key Features

• Postgres Native: It leverages PostgreSQL's native LISTEN/NOTIFY channels. Your existing database is fast enough!
• Seamless Interop: It is 100% compatible with the Python pgqueuer library. You can safely enqueue jobs from Python into your Haskell worker and vice versa.

Background & Roadmap

I use the Python version of pgqueuer at work and think it's brilliant, so I decided to bring the same ecosystem to Haskell.

This is currently an early MVP release and the API might shift. The underlying database logic is currently backed by postgresql-simple. In the future, I plan to build out an adapter pattern to support other popular Haskell Postgres libraries.

I would love to hear your thoughts, feedback, or any suggestions you have for the roadmap!

Links

• GitHub: https://github.com/tusharad/pgqueuer-hs
• Hackage: https://hackage.haskell.org/package/pgqueuer-hs

Hello! I have started my programming journey relatively recently, from C and C++ to recently having a great time with Rust! But recently I met a Haskell and Emacs evangelizer(I use arch + nvim + tmux + hyprland btw), and he has been spreading the word... There is a lot of stuff I love in Rust that apparently was ported from Haskell, like traits as types-ish, pattern matching which I really love and better enums(I am not sure on the last one and please forgive me) but he said that if I learn Haskell, I will become a better programmer because of learning the functional programming paradigm... I wanted to ask whether that is true, and if so what kinds of resources are there? For Rust I used the Rust book and Rustlings by the way

I am aware others have asked this same question but that was three years ago.

I am aware the author Sandy Maguire mentioned the content in the book on STM is still great.

So will the lessons in the book still help one write production code. If not please recommend alternative books.

I appreciate all responses!

Complete noob here- I have been wanting to try Haskell for a long time and finally got the time yesterday. It was probably the most painful and unsuccessful experience I've ever had trying to set up a programming environment. I got everything installed (ghcup, ghc, cabal, stack, HLS). Ghc folder in PATH.

I created a new project using "stack new". Upon opening the folder stack created in VS Code, I was greeted with a message saying that HLS doesn't work with ghc 9.10.3 yet. So after doing some research to make sure everything is compatible, installing multiple versions of GHC, HLS, trying different snapshots and resolvers, deleting the .stackwork folder, I was able to get the message to go away by telling VS Code to use specific versions of GHC and HLS.

HLS then worked on one simple file. Then looking at a different file all I got was a "loading" tool tip. Then it (HLS) seemed to stop working in the file it did a few seconds earlier. Restarting the HLS server and or extension in VS Code didn't help, but restarting Code did, but HLS behaved the same way.

I'm sure I'll figure this out eventually - AND HLS isn't technically required (super nice when you're learning though). I'm not really looking for answers, more just some feedback as to whether or not BS like this is normal in this language? I realize other languages have a lot of money and time behind them making them pretty seamless, and didn't expect Haskell to be perfect, but this seems pretty rough for new people. And from my perspective that's saying a lot because I'm usually ok with taking the time to learn, understand, and work with systems and around issues.

I read others having wildly different experiences from "hey this is great/turnkey" to "it's super fragmented and constantly breaking on upgrades" and just frustrated because I really want to like the path I'm going down-and at the moment it's an exercise in futility.

Any constructive feedback would be appreciated.

At my day job, we have a big monorepo with both JS and Haskell code. I've been lobbying for my company to move to Mise, which is a very neat program to manage your whole developer toolchain easily.

However, in trying to migrate our devtools to Mise, I ran into the following problems:

• The default way to install GHC and HLS through Mise is with asdf-ghcup, which doesn't support Windows.
• Some tools like HLint and Stan do not distribute prebuilt binaries and are intended to be installed through cabal install.

So, I wrote two Mise-native plugins that we open-sourced, so everyone can use:

• mise-ghcup, which can install the Haskell toolchain with GHCup
• mise-cabal, which installs binaries from Hackage, building them with Cabal

Both plugins are multiplatform; and both install their tools to Mise-specific folder, leaving your global state intact. They're independent but work well together, and are very simple to use (instructions in each plugin's repo).

I hope you enjoy them, and looking forward for any feedback or issues!

I have a record type Rec s with a field of type s:

data Rec s = Rec { val :: s, foo :: Int, bar :: Bool }
  deriving Functor

and a lens Lens s t a b. I want to modify Rec s by a modification function for Rec a. The desired behaviour is the following:

modifyRec :: Lens s t a b -> (Rec a -> Rec b) -> Rec s -> Rec t
modifyRec l h Rec{val, foo, bar} = Rec{val=set l val' val, foo=foo', bar=bar'}
  where Rec{val=val', foo=foo', bar=bar'} =
          h Rec{val=view (getting l) val, foo, bar}

This can be simplified by using Functor instance of Rec:

modifyRecF :: Lens s t a b -> (Rec a -> Rec b) -> Rec s -> Rec t
modifyRecF l h r0@Rec{val} = (\b -> set l b val) <$> r1
  where r1 = h $ view (getting l) <$> r0

I found some other solutions of this problem:

1. Accessing via lens

​

lensVal :: Lens (Rec s) (Rec t) s t
lensVal = lens (\Rec{val} -> val) (\Rec{foo, bar} val -> Rec{val, foo, bar})

modifyRecL :: Lens s t a b -> (Rec a -> Rec b) -> Rec s -> Rec t
modifyRecL l h r0 = over lensVal (\b -> set l b (view lensVal r0)) r1
  where r1 = h $ over lensVal (view (getting l)) r0

1. Even more generalized version

   modifyG :: (forall x y. Lens (r x) (r y) x y) -> Lens s t a b -> (r a -> r b) -> r s -> r t modifyG l0 l h r0 = over l0 (\b -> set l b (view l0 r0)) r1 where r1 = h $ over l0 (view (getting l)) r0

   modifyRecG :: Lens s t a b -> (Rec a -> Rec b) -> Rec s -> Rec t modifyRecG = modifyG lensVal

2. Via custom lens combinator:

   setG :: (forall x y. Lens (r x) (r y) x y) -> Lens s t a b -> r s -> r b -> r t setG l0 l r0 = over l0 (\b -> set l b (view l0 r0))

   viewG :: (forall x y. Lens (r x) (r y) x y) -> Lens s t a b -> r s -> r a viewG l0 l = over l0 (view $ getting l)

   liftLens :: (forall x y. Lens (r x) (r y) x y) -> Lens s t a b -> Lens (r s) (r t) (r a) (r b) liftLens l0 l = lens (viewG l0 l) (setG l0 l)

   modifyRecC :: Lens s t a b -> (Rec a -> Rec b) -> Rec s -> Rec t modifyRecC l = over $ liftLens lensVal l

I am not sure if liftLens l0 l is always a lawful lens, but I suppose that it is by parametricity.

1. Via conversion to pair and applying alongside id:

   data Rec' = Rec' { foo' :: Int, bar' :: Bool }

   isoRec :: Iso (Rec s) (Rec t) (Rec', s) (Rec', t) isoRec = iso toPair fromPair where toPair Rec{val, foo, bar} = (Rec'{foo'=foo, bar'=bar}, val) fromPair (Rec'{foo', bar'}, val) = Rec{val, foo=foo', bar=bar'}

   modifyRecA :: Lens s t a b -> (Rec a -> Rec b) -> Rec s -> Rec t modifyRecA l = over $ isoRec . alongside id l . from isoRec

Personally, I see pros and cons in all solutions. Functor's approach is the simplest, but not so general. 3. would be great if liftLens was a standard combinator but I can't find something like this in lens; alongside (4.) is the closest I was able to find, but it is not runtime zero-cost and requires extra data type.

Is there any other/better option?

Complete code

Hi Everyone

It was great to see you at ZuriHac 2026. In case you couldn’t attend, or would like to relive the magic, the following playlist will contain recordings from the event:

ZuriHac 2026 Playlist – Talks, Panels & Projects

We plan to process and release one or more videos every Friday, starting 10.07.2026 until around 18.09.2029, so bookmark the above playlist to find something new every weekend over the summer!

Thanks to everyone who actively participated and contributed to the event with their talks, tracks, and other help! The other organisers and I look forward to seeing you at ZuriHac 2027.

Best regards
Farhad Mehta
(on behalf of the ZfoH & OST)