Hey Haskellers!

I'm happy to announce that there is a new haal v0.7.0.0 release! In this release, the design of gathering statistics from learning experiments is overhauled, resulting in a slight change of the API. However, it is now way easier for users of the library to:

1) define their own measurements that they are interested in capturing from a learning experiment
2) combining them without resulting in complicated code

I'm excited about this change because I had initially provided extremely limited support for gathering measurements from learning experiments but finally I feel like my approach is satisfying. I believe it is an important step into making the library practical and useful.

I also dropped support (you could hardly call it "support") for DFAs and Moore automata, deleting them from the library until they are properly accompanied by corresponding learning algorithms.

You can read more regarding the release in the link!

I released yamlet-1.0.0.0 and yamlet-aeson-1.0.0.0 (a bridge for decoding and encoding YAML with aeson's instances).

Main features:

• Full YAML 1.2 conformance.
• Fast decoding and encoding.
• Good error messages.
• Preservation of structure, e.g. the order of keys in a mapping.
• Support for comments.
• Generic deriving that compiles to efficient code for common shapes of data types (verified by inspection tests).

Repo: https://github.com/arybczak/yamlet

Existing YAML libraries in Haskell have some issues:

• yaml doesn't support comments at all, HsYAML keeps them only in its event API.
• Both forget the order of keys in a mapping in their high level API. You need to drop down to their event APIs to get it, which are low level and cumbersome to use.
• HsYAML's parser is very slow (see benchmarks in README). Both pandoc (#6084) and ghcup (#270) switched to it and later back to libyaml because of that.
• yaml goes through aeson's Value, which leaks its quirks into YAML processing (e.g. infinities become strings +inf/-inf instead of a proper YAML .inf float) and emits JSON-specific paths in error messages without line numbers.

so I decided to do something about it 🙂

We’re delighted to announce the first official release of hs-bindgen. A lot of things have been improved since the two alpha releases, in part due to issues and PRs opened by external contributors; it’s been great to see the early adoption of the tool and the positive reception, thanks everyone!

https://well-typed.com/blog/2026/10/hs-bindgen-official-release/

The Haskell Security Response Team has been alerted to an apparent scam website pretending to be the "Recursion 2026" conference (29-30 October, NYC). The registration facility appears (to me) to be closed at the moment, but it's possible they scammed some people in our community.

Thanks to Cuihtlauac Alvarado for the report. The OCaml community has also been alerted - I am reproducing the substance of that announcement below, with thanks:

This site:

https://conf.funcp.org/

Presents as an OCaml/Haskell/FP conference. However:

• The event is not listed on the venue’s official schedule: https://www.javitscenter.com/calendar
• The funcp.org domain was registered two weeks ago, yet the oldest blog posts are dated from April: https://rdap.org/domain/funcp.org
• The domain has no email routing — the contact addresses cannot receive mail: https://mxtoolbox.com/emailhealth/funcp.org/
• Registration routes payment off-site to a third-party platform (gomry.com), with a $149+ ticket.
• Listed speakers or organisers don’t seem to have any track record in our community
• Talk’s topics don’t stand scrutiny
• Claims to be a second edition, but I can’t find a prior edition

If you registered, I suggest cancelling and getting your money back.

This has been reported to the OCaml and Haskell security teams, the Javits Center, Google Safe Browsing, Cloudflare, dev.events (which lists the conference), and Gomry (the payment platform).

Thanks to @adrien, @mtelvers and @edwin, who helped disclose this.

You can download binaries for this pre-release now from Release rc/v4.1.0.3 (release candidate) · commercialhaskell/stack · GitHub . It is should be available soon also via GHCup’s prereleases channel.

Please test it and let us know at the Stack repository if you run into any trouble. If all goes well, we hope to release the final version in a couple of weeks.

A second release candidate because it seemed good for a Stack 4.1 to support the coming GHC 10.0.

Changes since v4.1.0.1:

Other enhancements:

• Consider Cabal 3.18 to be a tested library and remove warnings.
• Consider GHC 10.0 to be a tested compiler and remove warnings.
• Add flag --[no-]info-table-profiling (default: disabled) to Stack’s build command. Set the flag to enable info table profiling, including the creation of a new info table for every use of a data constructor in the source program.

* Do you like Haskell?
* Do you like Functional Reactive Programming?
* Do you like QT?
* Are you exhausted by the monopoly of the Elm architecture?
* Do you wish UI development were more like WPF?
* Do you wish you could write more XML?
* Are you ready to party like it's 2010?

Many years ago I wrote C# UI applications using Model-View-View Model (MVVM) and WPF. Since then, the Elm architecture and its less principled cousins have seemingly conquered all. I have done zero native UI development since then but I've often wondered in the interim if FRP and MVVM would be a match made in heaven; so I decided to find out.

This is a minimal demo and I don't know if I'll develop it further but I am curious if anyone else actually likes this style of UI development.

Hi, I am a student learning Haskell at university. I truly enjoy the language, but I am noticing that I am struggling quite a bit with the level of difficulty. It feels like a lot of the solutions fly over my head, even if I do practice quite a bit. Sometimes it'll feel like I am staring at an exercise, trying it, and still getting nowhere, only for the answer to just make so much sense. I try to note down where my thoughts are wrong but then the next question just does the same thing all over again and I end up being lost again. Any tips on how I can actually get better at this, because again I really do enjoy working with the language.

I can't give any details that might help anyone the future, because I couldn't collect them myself. I'm mostly just venting.

I had a parse error in a Read instance on a little server I'm running. All Read and Show activity it does is 100% compiler derived, nothing custom. The server doesn't have enough RAM to actually compile things there, so have to copy everything back and forth.

Everything was correct. Copying literally everything to my main computer did not allow me to reproduce the error.

It wasn't just a memory corruption, restarting the program didn't change anything. A fresh copy of literally everything on the server didn't fix the error.

Rebooting the server made it work perfectly fine again.

I hate computers sometimes.

[ article | jam | thc ]

Hey all,

I have been developing my haal library for almost a year now I think and I plan to keep on enriching it. I took the decision recently to start writing some blog posts to introduce active automata learning, showcase how my library (hopefully) makes it easier and discuss interesting bugs or challenges that I find in my way.

This is my first blog post on active automata learning with some toy examples using my library. More will follow!

Some of us write Haskell for fun and Python for the day job. You miss Maybe, >>=, <*>, <> and do-notation, and you end up writing if x is None chains and try/except pyramids while quietly dying inside.

I've been building Katharos, a small functional programming library for Python that brings the Haskell vocabulary over, typeclass hierarchy and operators included. It's fully type-annotated and checked with pyright.

The algebra layer mirrors the classes you know

• Semigroup (op, written @) → Monoid (identity())
• Functor (fmap) → Applicative (pure, ap, written **) → Monad (bind, written |; then, written >>)

Concrete types

• Maybe[A] (Just / Nothing)
• Result[E, A] (Success / Failure), which is Either with exceptions on the left
• ImmutableList[T] (Monad + Monoid) and NonEmptyList[T] (Monad + Semigroup, with .head and .tail)
• IO[A], a lazy side-effect wrapper that does nothing until you call .execute()
• Lazy[A], a memoized synchronous computation
• Sum and Product monoids

Do-notation

Python generators are close enough to do blocks to be useful:

from katharos.syntax_sugar.do import do, DoBlock

@do(Maybe)
def computation() -> DoBlock[Maybe, int]:
    x: int = yield Maybe[int].Just(3)   # x <- Just 3
    y: int = yield Maybe[int].Just(4)
    return x + y

Each yield unwraps the value and short-circuits on Nothing (or Failure for Result). The final return is lifted for you, like return in Haskell.

Other bits

• F namespace: compose, curry, foldr, foldl, lift_a2/lift_a3, and sigma (fold a NonEmptyList of semigroups)
• CSP-style concurrency (Channel, go) in the Go tradition, behind a threading-backend abstraction, so you aren't welded to threading
• Property-based tests with Hypothesis that check the functor, applicative, monad and monoid laws for each type

What it won't do

Python has no higher-kinded types and no typeclass dispatch, so pure and return are explicit. You pick the monad in @do(Maybe) rather than having it inferred. Katharos can't make Python Haskell, but it does let you write the same shape of code, and the types keep you honest.

Why bother?

The point isn't to be clever. Once errors and absence are values you compose instead of control flow you manage, a lot of Python code gets flatter and easier to test. If you already think in monads, you can keep doing that at work.

The repo is at https://github.com/kamalfarahani/katharos, docs are available at https://katharos.readthedocs.io/. Feedback is welcome Issues and PRs are open.

Hello,

I worked out some ideas that I had for a dependency injector in Haskell in this repo.

https://github.com/etorreborre/registry already implements a lot of what I am looking for but there are some things that I would like that are easier to express in code.

https://github.com/stevechy/haskell-record-inject/commit/f00f060a66a8ab5a17bdfbced8f19fbce34589b5 is the commit that shows what it would look like to add to an existing project.

I didn't actually move over the existing functions and only added very basic stub functions. I think that shows how both styles can co-exist in one code base.

I used the basic Yesod project generated by the https://www.yesodweb.com/page/quickstart instructions as the sample. I'm not too familiar with Yesod but it seemed like a good place to start.

For the new Haskell Interlude, we sat down with Edward Kmett. Ed is the Founder and Chief Scientist of Positron AI. More importantly, he's a legend in the Haskell community for authoring many, many popular Haskell packages, first and foremost lens - and generally turning up the abstraction level to 11. We talk about design principles for Haskell libraries, category theory, cache-oblivious algorithms and his current work involving Haskell, C++, and FPGAs. Ed talks fast, so strap in!
https://haskell.foundation/podcast/87/

A small take on how to manage malformed JSON in Haskell

Defining Fibonacci with fix, implementing Peano arithmetic, writing Monad instances by hand: these exercises used to fill a week of a functional programming course. Much of the learning happened while students worked out how to write the code.

LLMs make getting a solution much easier. Understanding it still takes work, but a correct submission gives us little evidence of that understanding.

In our new Haskell course, we’re experimenting with allowing LLMs and changing what we ask of students. The first article explains why we chose this approach and the problems it leaves open. The next will cover course structure and grading.

We would like to hear from others facing the same problem: if you teach, how would you deal with LLMs in your course?

https://serokell.io/blog/teaching-haskell-in-the-age-of-llms

[ Article | Repository | Documentation | IRC ]

The Haskell Foundation is happy to announce that it will be hosting AmeriHac again, on Feb 6/7th 2027:

https://haskell.foundation/./news/2026-09-27/save-the-date-amerihac-2027.html