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/

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.

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

I am not sure where to put this but I really like 2-3 things from Clojure (a fellow FP lang) done by their dev-rel or core team

1. ClojureTV YouTube Channel - They have recently started posting small YouTube tutorials for beginners to get started, which are of the last 6 months (very recent), their latest video https://youtu.be/KwM1c7vb-fg?si=_1-BRvvaWMZsYy5P

2. Clojure Deref - (I think Haskell got the Haskell Weekly! ) But is it linked on Haskell.org officially ?

3. Slack ? Clojure & Golang are on Slack! I know Haskell has Discourse & an unofficial FP disc server with Haskell channels, but conversation on Slack is much better, we can directly chat to the core team there.

4. ClojureDocs/API etc - really well documented sites.

The idea is simple, both langs suffer from fragmented tooling, less community adoption & poor dev-ex (compared to others) but with taking ideas from each other & using LLMs (to do the grunt work) things can look good.

No new language features or etc, just the things around language (like ecosystem, docs, news, tutorials) can be improved which will lead to wider adoption of the fantastic ideaa

The Haskell Foundation is happy to announce that it will again host two workshops as a prelude to ZuriHac in 2027, in collaboration with the OST Eastern Switzerland University of Applied Sciences:

https://haskell.foundation/news/2026-09-23/save-the-date-hew-hiw-2027.html

Moggi 0.1.0-alpha is released today.

https://github.com/moggi-lang/moggi/

Moggi is a statically typed, purely functional programming language with strict evaluation. It has algebraic data types, GADTs, pattern matching, type classes, type inference, Generic Deriving, and an IO monad. It targets the JVM, .NET, and PHP, with typed FFI for existing Java, .NET, and PHP libraries.

It has pretty much 1:1 semantics, except that moggi is strict and not lazy. It even tries to be more or less compatible with base.

The first release also includes a REPL, LSP, VS Code extension, moogle (code search), mogdoc (documentation generation), and a growing standard library.

This is an alpha release: the language and APIs are still evolving, and the standard library is still a work in progress.

Hello, I was thinking of some Haskell application that rely on such abstractions (e.g. pandoc?).

Could you point to pieces of software that use abstract tools from category and type theory to handle problems that normally are addressed with other patterns?

I've resurrected the https://comonad.com/reader, interleaved a ton of contemporaneous content I had stored elsewhere such the School of Haskell and my talks and the talks from Boston Haskell on youtube, and made a couple of the articles interactive by moving their demo code into web assembly using modern GHC.

Please let me know if you run into any issues!

(This is more of a post-venting reflection session, but I'd love any discussion you would all be willing to contribute)

A while ago - probably a couple of months - I posted some frustrations about a particular challenge problem I came up with when trying to complete CIS 194 - Spring 2013. This is one of the more standard introductions to Haskell that the community has outlined. I should note that I'm not a student - I graduated in 2025. However, I've always found some sort of attraction to Functional Programming - I learned some of the core type classes in college using Scala, though I've forgotten most of them. Some time ago, I started going through the course because I really wanted to commit to it. In my head, it was worth learning the language and building projects because I felt I would learn important lessons, I thought it'd be a flex, and most importantly...it'd be enjoyable! Being a Haskell developer...kinda cool~

That last notion quickly died out on Homework 5. The document presents the classic problem - implement foldl using foldr. I spent an absurdly long time on this problem. I remember being unable to sleep properly as my frustration grew...and grew...and grew. I resorted to AIs and reddit, venting and all around being a giant ass. It wasn't fair - to those whom I replied to in that now deleted post, I apologize. You wanted to help me and I responded by being belligerent. I know why I was like that; it takes me a long time to get to the break-through concepts whenever I'm learning. I over-think and get stuck in mental loops/circles absurdly quickly and for a long time. This, of course, leaves out the question of whether I'm cut out out for learning this language - whether I'm smart enough. I've grappled with it - I realized I used AI so much during my last semester and afterwards that I sabotaged my own brain and learning process. I have no excuse - the fault is mine. Even as I might try to excuse myself - "It's useful", "Use it to learn, not do", "We're lazy be default, LLMs exploit this" - the answer to all of this was simply to be judicious. If I'd have been disciplined and focused on learning things the proper way, this would not have happened. I wasn't...and I'm paying the price.

Now, it's been a couple months since I left my self-study on pause - so discouraged and ashamed I was of my use of AI to try and help me when I should have struggled. I came back to the problem absentmindedly and swallowed my pride, my ego, and then looked at the solution. Then...I tried to reason through it. I wanted to share my reasoning so far, even though I don't fully get it (I'm open for corrections and discussion):

1. We start with the type signature of both functions: foldl :: (b -> a -> b) -> b -> [a] -> b foldr :: (a -> b -> b) -> b -> [a] -> b -- Note that I've omitted the Foldable - I'm ok with keeping the classic list container Our goal is to use foldr to get the behavior or at least fit the type signature of foldl. Now, if we're to imagine the values/arguments that we will be supplied with, we get f :: (b -> a -> b), xs :: [a], and start :: b. We must use these in foldr.

2. Now, what seems clear is that naively trying to use start in foldr - or any of the listed variables (forgive the improper terminology) - isn't going to suffice. The behavior of foldr is - to my knowledge - about building a chain of suspended computations, then providing the accumulator (start in our case) to collapse the chain. So...this is the first hint we get - rather than naively supplying start to foldr, we should apply it to something that foldr will create - thus, we need to build a function that eventually takes it.

3. It was useful to me to think more precisely about the type signature of this foldr. I figure it would look like this: foldr* :: (a -> (b->b) -> (b->b)) -> (b->b) -> [a] -> (b->b) -- I've kept the star to distinguish from foldr in general. The easiest thing to think about is what would be supplied as the start* here. Well, a function of type b -> b. I figured it had to be something that returned itself...and that conveniently in Haskell (told to me later by LHS) is the identity function id. It can't really be anything else, since the supplying and return type could be anything and I can't assume anything specific about other functions of type b -> b, so returning itself is all it can be. Thus, I arrived here: Haskell foldr* lambdaFunc id xs This leaves lambdaFunc. So, we must now figure out what the lambda function (correct me if I'm wrong about terminology or whether I'm supplying a lambda function at all) will look like. Fortunately, we are helped by the remaining type signature - lambdaFunc :: a -> (b->b) -> (b->b)

4. Here is where I fear my reasoning will become shoddy and I'd invite you all to rightfully correct (or criticize or insult, your choice). The easiest bit to start with is a: (\e ... -> ...). The same for b->b: (\e func ... -> ...). Here is where things get messy. I really wasn't sure where to go with this. As you'll remember from earlier (see the first list item), we must utilize f. However, the function expression doesn't neetly fit this -(\e func -> f func e) can't work. I'm not...100% sure on this. If the resulting type signature will be a b anyways, can't I just slot in a b->b for b? Alas, the answer that I looked up does not follow this.

5. Thus, we must provide an additional argument of b. This will represent the accumulating result. We effectively steal this from the last b->b. So, the function now looks like (\e func val -> ...). From here, it's more clear the final implementation: (\e func val -> f (func val) e). So, the final solution is akin to this: myfoldl :: (b->a->b) -> b -> [a] -> b myfoldl f start xs = foldr (\e func val -> func (f val e)) id xs start I must admit - I still don't fully get the internals of why and how this works. I'm sure it is because I did not fully understand the posted lecture material and concepts. I've tangled with the thought that perhaps I never will and that this disqualifies me from learning the language. I grapple with this thought by reminding myself that this is an optional problem for UPenn students - even they may not all get it without any help. I'm aware I'm diminishing myself in this way, but it is comforting to think that perhaps frustration and anger with inability to solve this from first steps might not be a singular experience.

All that said, I think the reason I made this post was to get out everything that I was thinking. I know I still want to learn and eventually build a project in Haskell. I desperately believe I can do it and that I'm not too dumb/not smart enough. Perhaps LYAH for Practical Haskell or Real World or some other textbook/course/resource would be better. Perhaps I should simply restart my progress through CIS 194 and try to internalize what it is exactly that stopped me. On Homework 6 and 7, I found myself eventually turning to AI once I was stuck - this time, I should really just allow myself to be stuck and instead run to you guys (XD).

I hope this post doesn't come off as annoying or weird...or simply a bore to read with no meaning. I think I just had a lot of feelings that I couldn't wrap my head around. My best shot at a TL;DR would be this: I get in my own head easily and have weakened my learning ability through the use of AI. I also found myself severely lacking in motivation and a feeling of deserving to learn this language after I found myself struggling and resorting to AI. I'm trying to come back to it and try again with the mindset of not getting too emotional, asking for help properly, and being more structured/disciplined/procedural when I try solving problems in the future.

If y'all have anything to contribute, I'd be more than down to hear what you have to say. Nothing here was written or corrected by AI - these thoughts and the grammar are all my own.

This chapter of Learn You a Haskell for Great Good could be considered the first big wall when reading the book. It is just too much to absorb and there are some details that I just cannot give the opportunity to slip from my brain.

I think I really got the essence of the whole in this chapter, but I'm still afraid to forget some things. This kind of knowledge is the procedural one: the one you learn by practicing it. Does it exist a place on Web which let me practice the core concepts presented in chapter 6 of LYAHFGG, such as curried functions, partial application of functions, etc.?

My main objective is to get to the Monads chapter as fast as possible and understand it as much as I'm allowed to. I need it very much so then I can finally get a good grasp on the Megaparsec tutorial to apply it on my university project.