February 2025 - Haskell-Cafe

Best way to implement "scoped exceptions"?
by Tom Ellis 27 May '25

27 May '25

I'd like to implement "scoped exceptions"[1], that is, a combinator of type withScopedException :: ((forall a. e -> IO a) -> IO r) -> IO (Either e r) so I can use exceptions in a convenient way, without having to set up fragile "action at a distance" based on the type of the thing I'm throwing and catching, for example: scopedExceptionExample :: IO (Either String (Either Int Void)) scopedExceptionExample = do withScopedException $ \throw1 -> withScopedException $ \throw2 -> if (1 :: Int) < 0 then throw1 "Hello" else throw2 1234 -- ghci> scopedExceptionExample -- Right (Left 1234) Here's a hacky way of doing it, based on tagging each exception with a unique value, and then filtering when handling: data MyException where MyException :: e -> Data.Unique.Unique -> MyException instance Show MyException where show _ = "<MyException>" instance Exception MyException withScopedException :: ((forall a. e -> IO a) -> IO r) -> IO (Either e r) wiathScopedException f = do fresh <- Data.Unique.newUnique flip tryJust (f (\e -> throwIO (MyException e fresh))) $ \case MyException e tag -> -- unsafeCoerce is very unpleasant if tag == fresh then Just (unsafeCoerce e) else Nothing This is the approach taken by the effectful library[2]. But is there a better way? Can I persuade GHC's RTS to work like this directly? Tom [1] I don't know if these already have a name [2] https://hackage.haskell.org/package/effectful-core-2.2.1.0/docs/src/Effectf…

5 7

CFP - Haskell Implementors' Workshop 2025
by Andreas Herrmann 27 Mar '25

27 Mar '25

Call for proposals for the Haskell Implementors' Workshop https://haskell.foundation/events/2025-haskell-implementors-workshop.html June 6, 2025 Organized by the Haskell Community Co-located with ZuriHac 2025 and Haskell Ecosystem Workshop 2025 Hosted by the Haskell Foundation at Eastern Switzerland University of Applied Sciences (OST) https://www.ost.ch/en/university-of-applied-sciences/campus/rapperswil-jona… ## Overview * Deadline: April 4, 2025 * Notification: May 5, 2025 * Workshop: June 6, 2025 The 17th Haskell Implementors' Workshop is to be held alongside ZuriHac 2025 this year near Zurich. It is a forum for people involved in the design and development of Haskell implementations, tools, libraries, and supporting infrastructure to share their work and to discuss future directions and collaborations with others. Talks and/or demos are proposed by submitting an abstract, and selected by a small program committee. There will be no published proceedings. The workshop will be informal and interactive, with open spaces in the timetable and room for ad-hoc discussion, demos, and lightning talks. In the past the Haskell Implementors’ Workshop was co-located with ICFP (International Conference on Functional Programming). However, in recent years it has become more and more challenging to attract a large enough audience and sufficiently many speakers for an appealing program. ZuriHac and the Haskell Ecosystem Workshop have become an important annual gathering of a large part of the Haskell community. This year the Haskell Implementors’ Workshop will be co-located with these events to be accessible to a broader audience. ## Scope and Target Audience The Haskell Implementors' Workshop is an ideal place to describe a Haskell extension, describe works-in-progress, demo a new Haskell-related tool, or even propose future lines of Haskell development. Members of the wider Haskell community are encouraged to attend the workshop - we need your feedback to keep the Haskell ecosystem thriving. Students working with Haskell are especially encouraged to share their work. The scope covers any of the following topics. There may be some topics that people feel we've missed, so by all means submit a proposal even if it doesn't fit exactly into one of these buckets: * Compilation techniques * Language features and extensions * Type system implementation * Concurrency and parallelism: language design and implementation * Performance, optimization and benchmarking * Virtual machines and run-time systems * Libraries and tools for development or deployment ## Talks We invite proposals from potential speakers for talks and demonstrations. We are aiming for 20-minute talks with 5 minutes for questions and changeovers. We want to hear from people writing compilers, tools, or libraries, people with cool ideas for directions in which we should take the platform, proposals for new features to be implemented, and half-baked crazy ideas. Submissions can be made via the form linked below until April 4, 2025 (anywhere on earth). https://docs.google.com/forms/d/e/1FAIpQLSdczGbxJYGc4eusvPrxwBbZl561PnKeYno… We will also have a lightning talks session. Lightning talks should be ~7mins and are scheduled on the day of the workshop. Suggested topics for lightning talks are to present a single idea, a work-in-progress project, a problem to intrigue and perplex Haskell implementors, or simply to ask for feedback and collaborators. ## Program Committee * Luite Stegeman * Jaro Reinders * Emily Pillmore * Rodrigo Mesquita * Ian-Woo Kim * Andreas Herrmann (chair) ## Contact * Andreas Herrmann

1 1

Midlands Graduate School - registration now open
by Graham Hutton 18 Mar '25

18 Mar '25

Dear all, Registration is now open for the Midlands Graduate School (MGS) in the Foundations of Computing Science, 7-11 April 2025, Sheffield, UK. Eight fantastic courses on category theory, type theory, coalgebra, semantics and more. Spaces are limited, so please register early to secure your place. Please share in your communities! Best wishes, Graham Hutton ========================================================== Midlands Graduate School 2025 7-11 April 2025, Sheffield, UK https://tinyurl.com/MGS-2025 BACKGROUND: The Midlands Graduate School (MGS) in the Foundations of Computing Science provides an intensive course of lectures on the mathematical foundations of computing. The MGS has been running since 1999, and is aimed at PhD students in their first or second year of study, but the school 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 all the introductory courses and choose additional options from the advanced courses depending on their interests. Invited course - Four Lectures on Proof-theoretic Semantics, David Pym Introductory courses - Category Theory, Thorsten Altenkirch - The Curry-Howard Correspondence, Anupam Das - Quantum Computing, Venanzio Capretta Advanced courses - Coalgebra, Paul Blain Levy - Linear Logic, Abhishek De and Charles Grellois - Modular Proofs in Isabelle/HOL, Chelsea Edmonds - Refinement Types in Haskell, Brandon Hewer REGISTRATION: The registration fee is £300 for academic participants, and £500 for industry participants. The fee includes all lecture courses and example classes, lunch and coffee breaks. The registration deadline is ** Monday 17th 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. ========================================================== — Professor Graham Hutton School of Computer Science University of Nottingham, UK http://www.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 1

Internship opportunity at NASA Ames Research Center -- Deadline Feb 28
by Ivan Perez 27 Feb '25

27 Feb '25

All, We have an opening for an internship opportunity at NASA Ames Research Center working on a Haskell project. The deadline is tomorrow Friday, Feb 28. I've posted the details here: https://www.reddit.com/r/haskell/comments/1ixmlei/haskell_internship_openin… Please have any students who qualify apply ASAP. Thanks, Ivan

1 0

GHC API stability initiative
by Facundo Domínguez 20 Feb '25

20 Feb '25

Dear all, At the end of last year I started collecting feedback from tool maintainers about the costs of dealing with GHC as a library. Eventually the feedback will be used to propose some actions to reduce these costs. Here's the last update on the initiative [1]. [1] https://discourse.haskell.org/t/ghc-api-stability-update-3/11407 This message is to broadcast the invitation for tool maintainers to share their feedback. I can be reached at facundo.dominguez(a)tweag.io, or you can reach me in the discourse thread as well. Best, Facundo

1 0

Midlands Graduate School 2025 hosted by the University of Sheffield
by Andrei Popescu 18 Feb '25

18 Feb '25

Dear Colleagues, This year's Midlands Graduate School in the Foundations of Computing Science will take place at the University of Sheffield. We have some great lecturers and topics. (Below you can also find information about fees. The registration site will open soon.) Best wishes, Andrei Midlands Graduate School 2025 7-11 April 2025, Sheffield, UK https://tinyurl.com/MGS-2025 BACKGROUND The Midlands Graduate School (MGS) in the Foundations of Computing Science provides an intensive course of lectures on the mathematical foundations of computing. The MGS has been running since 1999, and is aimed at PhD students in their first or second year of study, but the school 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 all the introductory courses and choose additional options from the advanced courses depending on their interests. Invited course - Four Lectures on Proof-Theoretic Semantics, David Pym Introductory courses - Category Theory, Thorsten Altenkirch - The Curry-Howard Correspondence, Anupam Das - Quantum Computing, Venanzio Capretta Advanced courses - Coalgebra, Paul Blain Levy - Linear Logic, Abhishek De and Charles Grellois - Modular Proofs in Isabelle/HOL, Chelsea Edmonds - Refinement Types in Haskell, Brandon Hewer FEES AND REGISTRATION The fees for MGS 25, which also cover catering (including coffee, pastries and lunch) during the day and optionally the conference dinner, are as follows. - Academic participant: £300, plus an optional £30 dinner ticket for Wednesday evening. - Industry participant: £500, plus an optional £30 dinner ticket for Wednesday evening. Registration will be open shortly. 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.

1 1

using the same data structure on a type level and as a value
by Zoran Bošnjak 15 Feb '25

15 Feb '25

Dear haskellers, I would like to reuse some (complex) data structures at a type level and as a regular value. The intention is to have the original specification on the type level (something like web API in Servant). But the idea is also to be able to convert the same structure to the value (of the same shape) and print it for example. There is no need to go from values back to types. I am not sure if Generic could help me do the conversion or do I need Typeable or even something else. I would like to avoid template haskell if possible, but please do advice if TH is the way to go in such cases. In my case, the data type structure is suppose to be the same, with the only difference being the 2 "primitives", which is: number is (Nat or Integer, depending on the usecase) and text is (Symbol or String). My attempt was something like this. import GHC.Generics -- not sure if this is required, but deriving works OK import GHC.TypeLits data Usecase = TypeLevel | ValueLevel -- Generic Int is 'Nat' or 'Integer'. type family GInt (u :: Usecase) where GInt 'TypeLevel = Nat GInt 'ValueLevel = Integer -- Generic Text is 'Symbol' or 'Text'. type family GText (u :: Usecase) where GText 'TypeLevel = Symbol GText 'ValueLevel = String -- Positive/zero or negative value. data PlusMinus = Plus | Minus deriving (Generic, Show) -- Now we can define generic plus/minus number. data PMInt (u :: Usecase) = PMInt PlusMinus (GInt u) deriving (Generic) deriving instance Show (PMInt 'ValueLevel) -- And we also define some more complex structure. data GNumber (u :: Usecase) = GNumInt (PMInt u) | GNumDiv (GNumber u) (GNumber u) | GNumPow (PMInt u) (PMInt u) deriving (Generic) deriving instance Show (GNumber 'ValueLevel) data GTest (u :: Usecase) = GTest [GInt u] [GText u] deriving (Generic) deriving instance Show (GTest 'ValueLevel) -- This does not work, but the idea is to define some type aliases -- In real application, this will be a huge list of structure descriptions (as types) type Example1 = 'PMInt 'Plus 3 -- GHC does not like '3' here?? type Example2 = 'PMInt 'Minus 4 type Example3 = 'GNumInt Example1 type Example4 = 'GNumDiv Example3 Example3 type Example5 = 'GTest '[ 1, 2, 3 ] '[ "Test1", "Test2"] -- 'convert' implementation ?? -- ... and be able to convert types to values, something like this val1 :: PMInt 'ValueLevel val1 = convert @Example1 -- ... or print it directly f :: IO () f = print ( convert @Example1, convert @Example2, convert @Example3 , convert @Example4, convert @Example5) Appreciate your suggestions. regards, Zoran

1 0

Re: [Haskell-cafe] Course-of-value recursion by defining a sequence as a self-referential infinite list
by Douglas McIlroy 10 Feb '25

10 Feb '25

> catalanNumbers :: Num a => [a] > catalanNumbers = > let xs = 1 : PowerSeries.mul xs xs > in xs This example of a generating function come to life as a program deserves to be better known. Bill Burge presented it 50 years ago in "Recursive Programming Techniques", Addison-Wesley, 1975. I revisited it in "Power series, power serious", JFP 9 (1999) 323-335, where, with overloadied arithmetic, it became ts = 1 : ts^2 The technique is laid bare in ten one-liners at https://www.cs.dartmouth.edu/~doug/powser.html. Doug

4 5

A Conversation With Sandy Maguire - Melbourne Haskell Users' Group - 28-03-2024
by John Walker 09 Feb '25

09 Feb '25

Hi All, Our interview with Sandy Maguire at Melbourne Haskell Users' Group, (now Melbourne Compose Group) is now on [YouTube](https://youtu.be/dnHIsr6gGnE). Sandy is well known in the Haskell and broader FP community, particularly as the author of: - [Thinking With Types](https://leanpub.com/thinking-with-types) - [Algebra Driven Design](https://leanpub.com/algebra-driven-design) - [Certainty By Construction](https://leanpub.com/certainty-by-construction) John

2 1

Re: [Haskell-cafe] Course-of-value recursion by defining a sequence as a self-referential infinite list
by Douglas McIlroy 08 Feb '25

08 Feb '25

>> Karczmarczuk’s solution via the Haskell prelude: >> >> part = 1 : b 1 >> where b n = (1 : b (n + 1)) + (replicate n 0 ++ b n) >> > This is broken code, no?, just 2 reasons I can spot why: > - function 'b n' calls 'b n' unconditionally (infite loop) > - What is the reutrn type of 'b'? It seems like it returns list, but the > return value is in the form 'a + b' , where (+) is instance of num so > I don't think prelude contains any ad-hoc definition of (+) that > returns list Not broken, just insufficiently documented. "part "is supposed to produce an infinite stream whose nth element is the number of distinct representations of n as a sum of positive integers. The "infinite loop" is deliberate, quite like ones = 1 : ones which generates an infinite sequence of 1s. It is not stated, but the (+) is understood to have been overloaded to handle lists of Nums in the natural way Doug

1 0