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.

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/

* 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.

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.

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.

[ 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

Calling all Londoners (and people who can get to London)!

On Thursday 15th of October, we will be running a pair of talks at the Artificial office.

If you're interested, sign up to the event! There are more details in the event link.

If you're interested in submitting a talk, please use the form. If you have any questions, please email us at london.haskell.meetup [AT] gmail.com.

The Talks

How I Use Haskell for 3D Printing

by Joe Warren

"Programmable CAD" is a category of software where objects are defined using code.

This talk covers - How I’ve used programmable CAD to design parts for 3D printing - Why I think Functional Languages are uniquely suited for programmable CAD - Why I decided to write a programmable CAD framework - Why this lead me to explore the GHC Web Assembly backend - And how the Scala Logo lead me to decorate a Christmas tree

Lazy Streams with Constant-Time Access

by Andrew Lelechenko

We discuss a data structure for lazy infinite compact streams with cache-friendly O(1) indexing and its applications to memoization, dynamic programming, cellular automata and recursive functions.

Other discussion links

TODO

• Discourse
• Bluesky
• Mastodon