Tootfinder

LLM-based Multi-Agent System for Intelligent Refactoring of Haskell Code
Shahbaz Siddeeq, Muhammad Waseem, Zeeshan Rasheed, Md Mahade Hasan, Jussi Rasku, Mika Saari, Henri Terho, Kalle Makela, Kai-Kristian Kemell, Pekka Abrahamsson
https://arxiv.org/abs/2506.19481

LLM-based Multi-Agent System for Intelligent Refactoring of Haskell Code
Refactoring is a constant activity in software development and maintenance. Scale and maintain software systems are based on code refactoring. However, this process is still labor intensive, as it requires programmers to analyze the codebases in detail to avoid introducing new defects. In this research, we put forward a large language model (LLM)-based multi-agent system to automate the refactoring process on Haskell code. The objective of this research is to evaluate the effect of LLM-based ag…

“Therefore, because baby loves baby, baby must be me.”
https://blog.jle.im/entry/the-baby-paradox-in-haskell.html

The Baby Paradox in Haskell
Everybody Loves My Baby is a Jazz Standard from 1924 with the famous lyric: Everybody loves my baby, but my baby don’t love nobody but me. Which is often formalized as: \begin{align} \text{Axiom}_1 . & \forall x. \text{Loves}(x, \text{Baby}) \\ \text{Axiom}_2 . \forall x. & \text{Loves}(\text{Baby}, x) \implies x = me \end{align} Let’s prove in Haskell (in one line) that these two statements, taken together, imply that I am my own baby.

Understanding Haskell-style Overloading via Open Data and Open Functions
Andrew Marmaduke, Apoorv Ingle, J. Garrett Morris
https://arxiv.org/abs/2507.16086

Understanding Haskell-style Overloading via Open Data and Open Functions
We present a new, uniform semantics for Haskell-style overloading. We realize our approach in a new core language, System F$_\mathrm{D}$, whose metatheory we mechanize in the Lean4 interactive theorem prover. System F$_\mathrm{D}$ is distinguished by its open data types and open functions, each given by a collection of instances rather than by a single definition. We show that System F$_\mathrm{D}$ can encode advanced features of Haskell's of type class systems, more expressively than current s…

@… Yeah, they got some cool features in there, such as const array sizes… why not push the boat a little?
But I can see why they shy away from them; it’s not like we *know* how to do dependent types well yet, and Rust has already made a couple of big type system bets.
(I found myself wishing for “shared xor mutable” in Haskell the other day.)…

Gravitational pulsars: correlations between the electromagnetic and the continuous gravitational wave signal
Marco Antonelli, Avishek Basu, Brynmor Haskell
https://arxiv.org/abs/2507.18439

Gravitational pulsars: correlations between the electromagnetic and the continuous gravitational wave signal
Neutron stars emitting continuous gravitational waves may be regarded as gravitational pulsars, in the sense that it could be possible to track the evolution of their rotational period with long-baseline observations of next-generation gravitational wave interferometers. Assuming that the pulsar's electromagnetic signal is tracked and allows us to monitor the pulsar's spin evolution, we provide a physical interpretation of the possible observed correlation between this timing solution and its g…

Functional programming isn't just for Haskell developers. It's for #PHP developers, too. "Thinking Functionally in PHP" is available from LeanPub.
https://leanpub.com/thinking-functiona

I chatted with @… and @… on the @… podcast !

This was so much fun - Alex has lots to say about art, programming, creativity, learning, and Haskell, of course!
https://functional.cafe/@HaskellInterlude/114816498470214539

from my link log —
Efficient communication and collection with compact normal forms in Haskell.
http://ezyang.com/papers/ezyang15-cnf.pdf
saved 2025-02-27

Just bought the book “Learn you a Haskell for great good”
Jo did you have many pain points of the language? @…
#haskell

@… We had someone whose entire job was to keep it working. (He was also the primary maintainer of rules_haskell, among other things.)

To Zip Through the Cost Analysis of Probabilistic Programs
Matthias Hetzenberger, Georg Moser, Florian Zuleger
https://arxiv.org/abs/2508.14249 https://arx…

To Zip Through the Cost Analysis of Probabilistic Programs
Probabilistic programming and the formal analysis of probabilistic algorithms are active areas of research, driven by the widespread use of randomness to improve performance. While functional correctness has seen substantial progress, automated reasoning about expected runtime remains comparatively limited. In this work, we address this challenge by introducing a refinement-typed probability monad in Liquid Haskell. Our monad enables automated reasoning about expected values and costs by encodi…

Freer Arrows and Why You Need Them in Haskell
Grant VanDomelen, Gan Shen, Lindsey Kuper, Yao Li
https://arxiv.org/abs/2506.12212 https://

Freer Arrows and Why You Need Them in Haskell
Freer monads are a useful structure commonly used in various domains due to their expressiveness. However, a known issue with freer monads is that they are not amenable to static analysis. This paper explores freer arrows, a relatively expressive structure that is amenable to static analysis. We propose several variants of freer arrows. We conduct a case study on choreographic programming to demonstrate the usefulness of freer arrows in Haskell.

girl who Hoogles every new emoticon in her DMs × girl who writes a haskell library every time she wants to use a new emoticon

from my link log —
MicroHs: Haskell implemented with combinators by Lennart Augustsson.
https://github.com/augustss/MicroHs
saved 2025-05-17 https:/…

It was almost the witching hour, so most people in this beach community are home and in bed. I was out #running and came across two big packs of teenagers, both of whom had someone with the stones to give me the “good evening, sir” treatment. Full on Eddie Haskell delivery. 😂
They are, of course, way too young to know about Eddie Haskell. What is their generational equivalent?
Anyway, t…

I think this is related to the issue that some people have with static typing: it’s a series of micro-interruptions that serve to distract from the goal.
While I never found this to be a problem in somewhat-typed languages such as Java, and I no longer have this problem most of the time in Haskell, I still experience it in Rust, where the borrow checker might require me to totally rethink my approach.
I can absolutely see why some people prefer not to have a type system.

@… @… In Haskell (und anderen funktionalen Programmiersprachen wie F#) ist eine Monade ein Begriff. Der wiederum entstammt der Kategorientheorie, wo eine Monade so etwas wie ein Monoid aus der Algebra ist.
(Diese Erklärung is…

Disabled veteran who is a US citizen was taken during Camarillo immigration raid, family says (Josh Haskell/ABC7)
https://abc7.com/post/disabled-veteran-is-us-citizen-was-taken-during-camarillo-immigration-raid-family-says/17072476/
http://www.memeorandum.com/250711/p93#a250711p93

@… It definitely lessens with practice and familiarity (and an editor that gives you lots of hints), but I don’t think it goes away entirely.
I definitely prefer to have my static type system and wrestle with it sometimes, but not always.
And I appreciate that Haskell, for example, *will* allow me to ignore cases in pattern-matching with a warnin…

from my link log —
A proper x86 assembler in Haskell using the Escardó-Oliva functional.
http://blog.vmchale.com/article/escardo-oliva-functional
saved 2025-08-06

"Professor Cain uses various programming languages to explain these concepts: he starts with C (roughly from the second lecture to the 8th), then Assembly (lectures 9 to 11), C (lectures 12 to 18), Scheme (lectures 19 to 23), and Python (from 24 to 26). The last lecture (27) dives into some other functional programming languages like ML, Miranda, and even Haskell, as well as some advanced type design concepts, to round up your general programming knowledge."

from my link log —
Violating memory safety with Haskell's value restriction.
https://welltypedwit.ch/posts/value-restriction.html
saved 2025-05-22

"Auf der Grenze": "Seit 100 Jahren steht die #Bibliothek #Haskell in #Kanada und den #USA

@… Some language servers do this. The Haskell Language Server, for example, will let you add an explicit type annotation for an implicitly typed variable or function. I think I’ve seen this for TypeScript too.
I’m not sure if this answers your question, but I hope it does.

#gleam on JavaScript is a bad fit, will give #PureScript a go, Haskell but with the huge npm ecosystem. How purescript’s ffi handles will be a deciding factor.
#functionalprogramming

from my link log —
Parsing layout, or: Haskell's syntax is a mess.
https://amelia.how/posts/parsing-layout.html
saved 2025-07-01

@… Are you using Nix to provision GHC C deps, then Cabal to get Haskell deps? Or using cabal2nix?

@… @… You might be interested in the proposed schedule for the implementors' workshop tomorrow.

from my link log —
The Epic Verse calculus: a core calculus for functional logic programming.
https://simon.peytonjones.org/verse-calculus/
saved 2025-06-12

I am once again asking GHC devs to make it possible for tooling such as HLint and the Haskell Language Server to compile against multiple versions of GHC.
I realise that this is a gigantic undertaking, but if you're wondering why people don't stick with Haskell, it might be because every compiler version upgrade breaks *everything*.

@… @… I spent 3 years being really into Rust but the shenanigans they have to get up to in order to make async work are horrifying, both in the language and for the user.
I have now gone back to Haskell.

I’m rewriting my logic language code in Haskell because I got frustrated with Rust’s verbosity and having to deal with garbage collection. I didn’t feel like it was adding enough, and I started to rethink my reasoning for using Rust (so it can be embedded anywhere). I don’t know if this language is going anywhere, maybe it’s fine if I have to rewrite it once it’s popular. It may never be.

After a couple of years of writing Rust for fun, writing Haskell feels like cheating.

Replaced article(s) found for cs.PL. https://arxiv.org/list/cs.PL/new
[1/1]:
- Describing Console I/O Behavior for Testing Student Submissions in Haskell
Oliver Westphal, Janis Voigtl\"ander

from my link log —
Type-level bounded recursion in Rust.
https://catgirl.ai/log/typelevel-bounded-recursion/
saved 2025-05-26

@… Oh, I totally get this. We had the same problem at my last job. Until we get a new GHC with a server-client architecture, I’m not holding my breath on a fix. (I hope to replace Cabal one day, but I’m not going to go and make a Haskell compiler. MicroHs is cool though.)
Maybe I met your coworkers! I didn’t go to any workshops because I’m lazy, I ju…

@… There are definitely massive downsides to using a niche language!
Last year I spent months having to deal with breaking changes in the Rust `http` package and all the knock-on effects though, so I’m not convinced it’s better elsewhere.
Haskell Language Server is in definite need of TLC, but there were some major QoL improvements made at Zuri…

@… I'll see if I can get the attention of a GHC dev. The Haskell implementors' workshop is tomorrow, and I won't be attending that, but maybe I'll get lucky.

@… @… Of course, but you can compile Agda to Haskell if you want to use it in a real program.

@… Yes, I am with you. I like writing Haskell for Serious Business, because I find I can work with the grain better than other languages, but for experimentation? No thanks. (I must learn a Lisp properly at some point. Got any recommendations?)

@… This is true, but I think there’s also a budget problem, in that the entire yearly budget for all Haskell tooling is approximately equivalent to a bag of oats and a nice juicy carrot.