March 2026 - Haskell-Cafe

tls v2.3.1
by Kazu Yamamoto 31 Mar '26

31 Mar '26

Hi all, I have just released the "tls" library version 2.3.1. As I said before, this version uses ML-KEM (Post-Quantum Cryptography) by default. Since no changes to the existing code are necessary, I released this as a minor version. However, ClientHello and ServerHello become larger by more than 1000 bytes. If the world breaks down, I will deprecate v2.3.1 and re-release a major version. I've written an explanatory article in Japanese. If you're interested, please read it using machine translation. https://eng-blog.iij.ad.jp/archives/35451 --Kazu

1 1

Re: HasCallStack constraint for maximum in Prelude?
by Olaf Klinke 28 Mar '26

28 Mar '26

> Mind you there's a conflict between the suggested `foldMap'` > implementation for Bounded elements and efficient implementations > with ordered Foldable collections (Map, IntMap, Set, ...). > > The latter, just return quickly return the least or greatest element > without paying a linear cost to perform the proposed fold. ... which is why functions like sum, product, maximum and minimum have become Foldable class methods, to be overridden whenever it is more efficient. I fail to see how your boundedMinimum reduces time complexity. It is still a general fold in the non-empty case. I wonder, though, how sustainable it is to bloat the Foldable interface with special cases of foldMap that can be overridden. What special monoid structures do exist that warrant a specialized fold implementation? We have (1) commutative monoids, such as Sum and Product, (2) semilattices, where (x<>) is idempotent for every x, (3) Short-circuiting monoids such as First and Last, where either (x<>) or (<>x) is constant for x /= mempty. Evidently, for cases (2) and (3) there are examples where the short- circuiting behavior of the monoid itself can be leveraged to short- circuit foldMap. Does anyone know of a real-world example where sum and product are overridden? All instances Hoogle turns up are O(n). I can't cast that into a type signature right now, but I feel all of null, sum, product, maximum, minimum can be unified given a suitable sub-class that relates the particular Foldable f to the contraint (Ord, Num etc.) present in the head of the function. Olaf

2 1

GHC 9.12.4 is now available
by Zubin Duggal 27 Mar '26

27 Mar '26

The GHC developers are very pleased to announce the release of GHC 9.12.4. Binary distributions, source distributions, and documentation are available at [downloads.haskell.org][] and via [GHCup](https://www.haskell.org/ghcup/). GHC 9.12.4 is a bug-fix release fixing many issues of a variety of severities and scopes, including: * Fixed a critical code generation regression where sub-word division produced incorrect results (#26711, #26668), similar to the bug fixed in 9.12.2 * Numerous fixes for register allocation bugs, preventing data corruption when spilling and reloading registers (#26411, #26526, #26537, #26542, #26550) * Fixes for several compiler crashes, including issues with CSE (#25468), and the simplifier(#26681), implicit parameters (#26451), and the type-class specialiser (#26682) * Fixed cast worker/wrapper incorrectly firing on INLINE functions (#26903) * Fixed LLVM backend miscompilation of bit manipulation operations (#20645, #26065, #26109) * Fixed associated type family and data family instance changes not triggering recompilation (#26183, #26705) * Fixed negative type literals causing the compiler to hang (#26861) * Improvements to determinism of compiler output (#26846, #26858) * Fixes for eventlog shutdown deadlocks (#26573) and lost wakeups in the RTS (#26324) * Fixed split sections support on Windows (#26696, #26494) and the LLVM backend (#26770) * Fixes for the bytecode compiler, PPC native code generator, and Wasm backend * The runtime linker now supports COMMON symbols (#6107) * Improved backtrace support: backtraces for `error` exceptions are now evaluated at throw time * `NamedDefaults` now correctly requires the class to be standard or have an in-scope default declaration, and handles poly-kinded classes (#25775, #25778, #25882) * ... and many more A full accounting of these fixes can be found in the [release notes][]. As always, GHC's release status, including planned future releases, can be found on the GHC Wiki [status][]. GHC development is sponsored by: * [Juspay](https://juspay.com/) * [QBayLogic](https://qbaylogic.com/) * [Channable](https://www.channable.com/) * [Haskell Foundation](https://haskell.foundation/) * [Serokell](https://serokell.io/) * [Well-Typed](https://well-typed.com/) * [Tweag](https://www.tweag.io/) * [Dotcom-Monitor](https://www.dotcom-monitor.com/) * [LoadView](https://www.loadview-testing.com/) * [Web Hosting Buddy](https://webhostingbuddy.com/) * [Find My Electric](https://www.findmyelectric.com/) * [Standard Chartered](https://www.sc.com) * [UpCloud](https://upcloud.com) * [Mercury](https://mercury.com) We would like to thank these sponsors and other anonymous contributors whose on-going financial and in-kind support has facilitated GHC maintenance and release management over the years. Finally, this release would not have been possible without the hundreds of open-source contributors whose work comprise this release. As always, do give this release a try and open a [ticket][] if you see anything amiss. [release notes]: https://gitlab.haskell.org/ghc/ghc/-/blob/ghc-9.12/docs/users_guide/9.12.4-… [status]: https://gitlab.haskell.org/ghc/ghc/-/wikis/GHC-status [downloads.haskell.org] https://downloads.haskell.org/ghc/9.12.4 [ticket]: https://gitlab.haskell.org/ghc/ghc/-/issues/new

1 0

Call for Submissions: ICFP 2026 Student Research Competition
by Kimball Germane 27 Mar '26

27 Mar '26

ICFP 2026 Student Research Competition Call for Submissions ICFP 2026 invites students to participate in the Student Research Competition in order to present their research and get feedback from prominent members of the programming language research community. The SRC consists of three rounds: * Submission of an extended abstract * Poster session at ICFP 2026 * Finalists' presentations at ICFP 2026 During the first round students submit an extended abstract detailing their research to be reviewed by the program committee. Those students whose abstracts get accepted advance to the poster session round which will take place during ICFP 2026. Winners of the poster session advance to the next round, where they will give a 5-minute presentation about their work on the ICFP main stage in front of a live audience. IMPORTANT DATES AND TIMES * Submission Deadline: 11 May 2026 (Monday) * Author Notification: 1 June 2026 (Monday) * ICFP 2026 Conference in Indiana, USA: 24 August 2026 (Monday) - 26 August 2026 (Wednesday) SUBMISSION OF EXTENDED ABSTRACTS * Submission Website: https://icfp26src.hotcrp.com Each submission (referred to as "abstract" below) should include the student author's name and email address; institutional affiliation; research advisor's name; ACM student member number; category (undergraduate or graduate); research title; and an extended abstract addressing the following: * Problem and Motivation: Clearly state the problem being addressed and explain the reasons for seeking a solution to this problem. * Background and Related Work: Describe the specialized (but pertinent) background necessary to appreciate the work in the context of ICFP areas of interest. Include references to the literature where appropriate, and briefly explain where your work departs from that done by others. * Approach and Uniqueness: Describe your approach in addressing the problem and clearly state how your approach is novel. * Results and Contributions: Clearly show how the results of your work contribute to programming language design and implementation in particular and to computer science in general; explain the significance of those results. * Submissions must be original research that is not already published at ICFP or another conference or journal. One of the goals of the SRC is to give students feedback on ongoing, unpublished work. Furthermore, the abstract must be authored solely by the student. If the work is collaborative with others and/or part of a larger group project, the abstract should make clear what the student's role was and should focus on that portion of the work. * Formatting: Submissions must be in PDF format, printable in black and white on US Letter sized paper, and interpretable by common PDF tools. All submissions must adhere to the "ACM Small" template that is available (in both LaTeX and Word formats) from https://www.acm.org/publications/authors/submissions. For authors using LaTeX, a lighter-weight package, including only the essential files, is available from http://sigplan.org/Resources/Author/#acmart-format. The submission must not exceed 3 pages in PDF format. Reference lists do not count towards the 3-page limit. Further information is available at the ICFP SRC website: https://icfp26.sigplan.org/track/icfp-2026-src

1 0

Re: HasCallStack constraint for maximum in Prelude?
by Olaf Klinke 26 Mar '26

26 Mar '26

> Adding that warning won't affect performance, but it would guide > people > to never use them (Especially Foldable variant; its type is wrong - > it > would make some sense with Bounded - if Bounded were related to Ord). > For (Bounded a, Ord a) one should replace maximum by an ordinary fold, given a suitable newtype wrapper with a Monoid instance, e.g. (Ord a, Bounded a) => Monoid (Data.Semigroup.Max a) In the past I've also used custom newtypes if e.g. I knew all values were non-negative and the least value I cared about was zero. -- Olaf

3 6

Re: HasCallStack constraint for maximum in Prelude?
by Olaf Klinke 26 Mar '26

26 Mar '26

Mathematically, the least amount of structure needed for maximum and minimum is a bounded semilattice, which in contrast to the Bounded class requires only one bound to exist. Such structures are defined for example in the semilattices [1] and lattices [2] packages. The semilattices package provides the instances (Lower a, Join a) => Monoid (Joining a) (Upper a, Meet a) => Monoid (Meeting a) whereas the lattices package provides the BoundedJoinSemilattice and BoundedMeetSemilattice classes and the functions joins :: (BoundedJoinSemiLattice a, Foldable f) => f a -> a meets :: (BoundedMeetSemiLattice a, Foldable f) => f a -> a joins1 :: (Lattice a, Foldable1 f) => f a -> a meets1 :: (Lattice a, Foldable1 f) => f a -> a as well as the wrappers Meet and Join with appropriate Monoid instances to recover the joins and meets functions via foldMap. Olaf [1] https://hackage.haskell.org/package/semilattices [2] https://hackage.haskell.org/package/lattices

1 0

Midlands Graduate School, 13-17 April 2026, Nottingham UK
by Graham Hutton (staff) 25 Mar '26

25 Mar '26

Dear all, *** Registration extended until Sunday 29th March *** There are just a few days left now to register for this years Midlands Graduate School (MGS) in Nottingham. Eight fantastic courses on type theory, category theory, lambda calculus and more. 13-17 April 2026, Nottingham, UK. Best wishes, Graham ========================================================== MIDLANDS GRADUATE SCHOOL 2026 13-17 April 2026, Nottingham, UK https://tinyurl.com/MGS-2026 ========================================================== BACKGROUND The Midlands Graduate School (MGS) in the Foundations of Computing Science provides a yearly programme of courses on the mathematical foundations of computing, and recently celebrated its 25th year. The MGS is primarily aimed at PhD students in their first or second year, but is open to everyone, and has increasingly seen participation from industry. We welcome participants from all over the world! COURSES Eight courses will be given. Participants usually take around four courses, depending on their interests. Invited course: - Implement your POPL paper (using Haskell) Stephanie Weirich (Pennsylvania) Introductory courses: - Type Theory using Agda Thorsten Altenkirch (Nottingham) - Category Theory Sergey Goncharov (Birmingham) - Lambda Calculus and Combinatory Algebra Sam Speight (Birmingham) Advanced courses: - Effects and Call-By-Push-Value Paul Blain Levy (Birmingham) - Synthetic Homotopy Theory Axel Ljungström (Nottingham) - Categorical Algebra and Logic Sean Moss (Birmingham) - Inductive and Coinductive Reasoning with Isabelle/HOL Andrei Popescu (Sheffield) REGISTRATION Student participants: £350 (or £600 with accommodation) Industry participants: £800 (or £1050 with accommodation) The registration fee includes all lecture courses and example classes, lunch and coffee breaks, and the conference dinner. The 'with accommodation' options include five nights at Rutland Hall with shared bathroom facilities. Registration closes Sunday 29th March. Spaces are limited, so please register early to secure your place. SPONSORSHIP We offer a range of sponsorship opportunities for industry (bronze, silver, gold and platinum), each with specific benefits. Please see the website for further details. LOCAL ORGANISERS For any queries, please contact the local organisers: Ulrik Buchholtz <ulrik.buchholtz(a)nottingham.ac.uk> Dan Marsden <dan.marsden(a)nottingham.ac.uk> ========================================================== -- Professor Graham Hutton School of Computer Science University of Nottingham, UK http://people.cs.nott.ac.uk/pszgmh This message and any attachment are intended solely for the addressee and may contain confidential information. If you have received this message in error, please contact the sender and delete the email and attachment. Any views or opinions expressed by the author of this email do not necessarily reflect the views of the University of Nottingham. Email communications with the University of Nottingham may be monitored where permitted by law.

1 0

HasCallStack constraint for maximum in Prelude?
by Todd Wilson 24 Mar '26

24 Mar '26

Should maximum and minimum have HasCallStack constraints like head and tail do? ghci> :type head head :: GHC.Stack.Types.HasCallStack => [a] -> a ghci> head [] *** Exception: Prelude.head: empty list CallStack (from HasCallStack): error, called at libraries/base/GHC/List.hs:1646:3 in base:GHC.List errorEmptyList, called at libraries/base/GHC/List.hs:85:11 in base:GHC.List badHead, called at libraries/base/GHC/List.hs:81:28 in base:GHC.List head, called at <interactive>:8:1 in interactive:Ghci1 ghci> :type maximum maximum :: (Foldable t, Ord a) => t a -> a ghci> maximum [] *** Exception: Prelude.maximum: empty list CallStack (from HasCallStack): error, called at libraries/base/GHC/List.hs:1646:3 in base:GHC.List errorEmptyList, called at libraries/base/GHC/List.hs:717:28 in base:GHC.List maximum, called at libraries/base/Data/Foldable.hs:745:15 in base:Data.Foldable Todd Wilson

4 4

Functional design question
by Joachim Durchholz 24 Mar '26

24 Mar '26

Hi all, I have some design questions - not for Haskell but for the Java+Vavr combo, but I am about to dip my toes into actual work in a functional manner, as far as that is possible, and I thought I might as well go for the community that's best subscribed to a purely functional style. Bird's eye view: Java everybody knows (I don't like it either, no worries), Vavr is a - to my eyes - pretty nice functional library, https://docs.vavr.io/ for details if you're actually interested. I want to leverage Vavr to get a Java program to be as Haskell-ish as is reasonable; that's not going to be much by a Haskeller's standards, but... baby steps. Application is a simple command-line thing: Read configuration from command line and configuration file, emit diagnostics about any errors in the config, then process. I want the configuration processing to be as functional as reasonable, given the constraints. However, I'm undecides about many things, no doubt because I simply don't know the best design patterns, and it's frustrating to see multiple options and not knowing which ones will paint me into a corner and which ones will not. Things I'm undecided about: a) Data type variations During the configuration phase, I need to carry information about where some configuration item came from (its ("context", usually file, line number, column number). In the processing phase, configuration is considered final and error-free, so context is not needed (that's a done design decision). I could carry context information into the processing phase, but it's going to be awkward: Say, we have the following types (forgive the most un-Haskellish pseudo syntax but I don't dare to use Haskell style because I'd almost certainly get that wrong and provoke misunderstandings) DirectoryConfig { ConfigData<Path> path ConfigData<String> title ... } data ConfigData<a> { String fileName int lineNumber int columnNumber a value } but in the processing phase I don't want my config objects polluted with context, so I want DirectoryConfig { Path path String title ... } No idea how to deal with that. I'd use code generation in Java I guess, but that's horribly inelegant and complicated to set up (no, I don't particularly like Java, it's just what I'm currently using). So... how would one do such a thing in a functional language? Not necessarily Haskell, I guess some language extensions exist for that kind of stuff, but I'm more-or-less tied to Java + functional libraries, so I'll have to stick with the more basic approaches most likely. Besides, even if I did Haskell, I'd want to avoid the advanced stuff until I get confident in the basics. TL;DR: I have a deeply nested configuration data structure where each field has a "context", i.e. the place it came from; how to I make it so that the context is available during configuration evaluation but is unavailable in the later processing phase? I hope this is understandable; it's really hard to do that when you don't even know enough to ask the questions precisely enough. Regards, Jo

4 7

AI for Math Summer Fellowship -- Copilots for Isabelle (Sheffield / Copenhagen / London): application deadline April 10
by Andrei Popescu 21 Mar '26

21 Mar '26

Dear Colleagues, We are pleased to advertise an AI for Math Summer Fellowship opportunity on the project "Copilots for Isabelle: Learning Logical Structure for a Better Proving Experience". The general call and application details (including an application link) can be found here: https://docs.google.com/document/d/1tXlT2A2NyLi_N-Fn1Q5zwG6J0b8Cwhzj/edit Please note that the application deadline is April 10, and the internship will run for 10 weeks, from June 15 to August 21, 2026. In this project, the selected fellow will work with researchers at the University of Sheffield, University of Copenhagen, and King’s College London on developing AI-based copilots for the Isabelle proof assistant. The aim is to leverage the rich structure of interactive proofs to build intelligent tools that assist with proof development, documentation, and automation. The fellowship offers the opportunity to work on topics such as: -- generating polished proofs from informal or partial drafts, -- automatically producing documentation for Isabelle/ML code, -- adapting and tuning LLMs for proof tasks. The position is open to undergraduate, master’s and PhD students, and can be carried out in Sheffield, Copenhagen, or London (with support for travel if needed). Please see the attached project description for further details. Best wishes, Andrei, Dmitriy and Mohammad

1 0