Hashtag

#Haskell

1,762 posts tagged with this hashtag.

Abhinav 🧭
@abnv@fantastic.earth

Ever since I figured out how to build static executables for code, I've being deploying all my Haskell projects as static binaries. I can't believe how much disk space it saves in some cases. The SSG that builds my website used to take more than 5GB; now it takes about 80MB!

Screenshot of a terminal with text: > nix path-info -Sh (nix-build --quiet nix/release.nix) /nix/store/84vc1j299cf1578kspj7075kfhhl4ffa-site-1.0.0 5.4G > nix path-info -Sh (nix-build --quiet --arg static true nix/release.nix) /nix/store/ciag7rx<mdvaa19919jg6bybbwxp1s9n-site-1.0.0 84.0М
ALT text

Screenshot of a terminal with text: > nix path-info -Sh (nix-build --quiet nix/release.nix) /nix/store/84vc1j299cf1578kspj7075kfhhl4ffa-site-1.0.0 5.4G > nix path-info -Sh (nix-build --quiet --arg static true nix/release.nix) /nix/store/ciag7rx<mdvaa19919jg6bybbwxp1s9n-site-1.0.0 84.0М

Abhinav 🧭
@abnv@fantastic.earth

feed-repeat now has a (simple) website: abhin4v.github.io/feed-repeat/

abhin4v.github.io

feed-repeat

Abhinav 🧭
@abnv@fantastic.earth

feed-repeat now has a (simple) website: abhin4v.github.io/feed-repeat/

abhin4v.github.io

feed-repeat

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared June 5, 2026. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared June 5, 2026

The readings shared in Bluesky on 5 June 2026 are: A formal proof of the Ramanujan-Nagell theorem in Lean 4. ~ Barinder S. Banwait. #LeanProver #ITP #AI4Math Certificate-based verification of derivat

Philipp :emacs: :nixos:
@pmidden@fosstodon.org

In , I have "load :: Bool -> Bool -> Struct" where "data Struct = Struct (Maybe X) (Maybe Y)" (where the booleans specify whether X and Y are loaded and are "Just"). If the two booleans are more or less known at compile-time, can I improve on this, ditching the Maybe?

Brian McKenna
@puffnfresh@mastodon.social

I've been working on continually exporting 's stack traces to pprof format, making GHC compatible with existing tools, e.g. Pyroscope, Speedscope, etc.

Simple tests give it about a 2% overhead on a silly Scotty/HTTP example app.

That brings it in line with other languages. For Atlassian Marketplace, I used AWS CodeGuru Profiler for the Scala code, and it was invaluable. For Obsidian Systems we've been using Grafana Pyroscope on some Go code.

Haskell call graphs in Grafana Pyroscope.
ALT text

Haskell call graphs in Grafana Pyroscope.

Haskell call stack visualised with "go tool pprof"
ALT text

Haskell call stack visualised with "go tool pprof"

HaskellOrg
@haskell@fosstodon.org

The past years have seen horrendous attacks towards trans people. We have a duty to protect the most vulnerable members of our communities.

There is no without the trans people who have shaped it through the years.

This June is a month of celebrations, but the struggle continues. ✊🏳️‍⚧️λ

The trans flag with a greek lowecase lambda letter in black on it.
ALT text

The trans flag with a greek lowecase lambda letter in black on it.

HaskellOrg
@haskell@fosstodon.org

The past years have seen horrendous attacks towards trans people. We have a duty to protect the most vulnerable members of our communities.

There is no without the trans people who have shaped it through the years.

This June is a month of celebrations, but the struggle continues. ✊🏳️‍⚧️λ

The trans flag with a greek lowecase lambda letter in black on it.
ALT text

The trans flag with a greek lowecase lambda letter in black on it.

HaskellOrg
@haskell@fosstodon.org

The past years have seen horrendous attacks towards trans people. We have a duty to protect the most vulnerable members of our communities.

There is no without the trans people who have shaped it through the years.

This June is a month of celebrations, but the struggle continues. ✊🏳️‍⚧️λ

The trans flag with a greek lowecase lambda letter in black on it.
ALT text

The trans flag with a greek lowecase lambda letter in black on it.

HaskellOrg
@haskell@fosstodon.org

The past years have seen horrendous attacks towards trans people. We have a duty to protect the most vulnerable members of our communities.

There is no without the trans people who have shaped it through the years.

This June is a month of celebrations, but the struggle continues. ✊🏳️‍⚧️λ

The trans flag with a greek lowecase lambda letter in black on it.
ALT text

The trans flag with a greek lowecase lambda letter in black on it.

Philipp :emacs: :nixos:
@pmidden@fosstodon.org

Finally got a good use-case for property-based tests (PBT) in . Had a function that really enforced an invariant. Given a number, using test to be tested function will output a string that's less than 'n' chars long. And wow did PBT help!

HaskellOrg
@haskell@fosstodon.org

Request For Comments:
H2JVM - A Library for writing Bytecode

discourse.haskell.org/t/h2jvm-

discourse.haskell.org

H2JVM - A Haskell Library for writing JVM Bytecode

Hi everyone! I have been working on a new library for writing JVM bytecode with Haskell in a nice, high level way and I’d love some feedback on it! The motivation here is for compilers to the JVM so they can focus on the actual code generation, meanwhile H2JVM takes care of all the messy details like StackMapTable analysis, label/offset resolution, etc. Here is a quick example taken from the readme. It generates a simple class file with a single method static int add(int, int) which adds 2 num...

Lobsters
@lobsters@mastodon.social

H2JVM - A Haskell Library for writing JVM Bytecode lobste.rs/s/8043lu
discourse.haskell.org/t/h2jvm-

discourse.haskell.org

H2JVM - A Haskell Library for writing JVM Bytecode

Hi everyone! I have been working on a new library for writing JVM bytecode with Haskell in a nice, high level way and I’d love some feedback on it! The motivation here is for compilers to the JVM so they can focus on the actual code generation, meanwhile H2JVM takes care of all the messy details like StackMapTable analysis, label/offset resolution, etc. Here is a quick example taken from the readme. It generates a simple class file with a single method static int add(int, int) which adds 2 num...

HaskellOrg
@haskell@fosstodon.org

Serokell’s Work on GHC: Dependent Types, Part 5

serokell.io/blog/serokell-s-wo

serokell.io

Serokell’s Work on GHC: Dependent Types, Part 5

This article continues the fine tradition of Serokell's GHC team sharing their progress on bringing dependent types to Haskell. A lot has happened since the last report, and there is plenty to cover. In this edition, Vladislav Zavialov presents three major contributions and a host of smaller improvements that push Dependent Haskell closer to becoming a practical reality.

HaskellOrg
@haskell@fosstodon.org

Request For Comments:
H2JVM - A Library for writing Bytecode

discourse.haskell.org/t/h2jvm-

discourse.haskell.org

H2JVM - A Haskell Library for writing JVM Bytecode

Hi everyone! I have been working on a new library for writing JVM bytecode with Haskell in a nice, high level way and I’d love some feedback on it! The motivation here is for compilers to the JVM so they can focus on the actual code generation, meanwhile H2JVM takes care of all the messy details like StackMapTable analysis, label/offset resolution, etc. Here is a quick example taken from the readme. It generates a simple class file with a single method static int add(int, int) which adds 2 num...

Abhinav 🧭
@abnv@fantastic.earth

Over the weekend, I spent a couple of hours through Patrick Thomson's series of blog posts on Recursion Schemes with blog.sumtypeofway.com/posts/re, and it has been most helpful in understanding the topic. I have tried reading the docs of the eponymous package before, to no avail. That's why I love reading (and writing) tutorials.

I downloaded the posts and converted them to an e-book for offline reading. It was over a hundred pages but it was so engrossing, I couldn't put it down! There are not many blog posts that I could say the same about. Definitely a recommended read if you are interested in and .

blog.sumtypeofway.com

adventures in uncertainty: Recursion Schemes, Part VI: Comonads, Composition, and Generality

HaskellOrg
@haskell@fosstodon.org

OpenTelemetry 1.0 release!!

discourse.haskell.org/t/ann-op

discourse.haskell.org

[ANN] OpenTelemetry 1.0 release

Hello, all! After a number of years and false starts on trying to wrap my head around the metrics spec, I’m pleased to announce the release of the 1.0 edition of the hs-opentelemetry-* ecosystem! OpenTelemetry is an open source observability framework that provides a single set of APIs, libraries, agents, and collector services to capture distributed traces and metrics from your application. The reason this is 1.0 and not yet another 0.x is that it is a big bang release with a number of break...

Dr. Friedrich von Never
@fornever@dotnet.social

Took me a couple of months in total, but finally I've released Haskeletor v2.0.0 — an plugin for projects!

This time, in v2.0.0, it is really an IntelliJ plugin — no longer bound to IDEA, compatible with all the IDEs from the family!

There are a lot of plans how to move farther (e.g. rely on HLS instead of the current tool set), but for now I've released it and plan to switch to other tasks — the ones that made me to implement Haskell tooling in the first place.

Dr. Friedrich von Never
@fornever@dotnet.social

Took me a couple of months in total, but finally I've released Haskeletor v2.0.0 — an plugin for projects!

This time, in v2.0.0, it is really an IntelliJ plugin — no longer bound to IDEA, compatible with all the IDEs from the family!

There are a lot of plans how to move farther (e.g. rely on HLS instead of the current tool set), but for now I've released it and plan to switch to other tasks — the ones that made me to implement Haskell tooling in the first place.

HaskellOrg
@haskell@fosstodon.org

RFC: Sunsetting i386 bindists?

i386 has been a source of pain for a while with musl libc. Should it be retired, or should the bindings switch to glibc and be less portable?

discourse.haskell.org/t/rfc-su

discourse.haskell.org

[RFC] Sunsetting i386?

i386 has been a source of pain for a while. More specifically: Something seems wrong with ghcup installing bindist for i386 on debian 12 · Issue #1107 · haskell/ghcup-hs · GitHub Test failures on 32bit linux (alpine/musl) · Issue #11049 · haskell/cabal · GitHub https://gitlab.haskell.org/ghc/ghc/-/issues/25945 And currently blocking Cabal CI because alex --version segfaults. It also so happens that I build the alpine 32bit GHC variant for every single release manually. I think it’s beyond r...

Lobsters
@lobsters@mastodon.social

Haskell Foundation 2026 Update lobste.rs/s/9qfw9k
discourse.haskell.org/t/haskel

discourse.haskell.org

Haskell Foundation 2026 Update

The Haskell Foundation has been at the center of a flurry of changes, all of which I’d like to share with the community today. First, José, our executive director for the past few years, has decided to step away from his role in June 2026. José has been the longest-serving executive director at the Haskell Foundation, spending his time interacting with and supporting the community in many ways, often away from public view. Through personal sacrifices, José has allowed the Haskell Foundation to ...

Adolfo Neto
@adolfoneto@bertha.social

Functional Programming - Humble Tech Book Bundle

humblebundle.com/books/ultimat

humblebundle.com

Humble Tech Book Bundle: The Ultimate Functional Programming by Pragmatic Programmers

Pay what you want for a curated collection of functional programming courses by Pragmatic Programmers and help support Save the Children with your purchase!

HaskellOrg
@haskell@fosstodon.org

Haskell Foundation 2026 Update

discourse.haskell.org/t/haskel

discourse.haskell.org

Haskell Foundation 2026 Update

The Haskell Foundation has been at the center of a flurry of changes, all of which I’d like to share with the community today. First, José, our executive director for the past few years, has decided to step away from his role in June 2026. José has been the longest-serving executive director at the Haskell Foundation, spending his time interacting with and supporting the community in many ways, often away from public view. Through personal sacrifices, José has allowed the Haskell Foundation to ...

HaskellOrg
@haskell@fosstodon.org

Haskell Foundation 2026 Update

discourse.haskell.org/t/haskel

discourse.haskell.org

Haskell Foundation 2026 Update

The Haskell Foundation has been at the center of a flurry of changes, all of which I’d like to share with the community today. First, José, our executive director for the past few years, has decided to step away from his role in June 2026. José has been the longest-serving executive director at the Haskell Foundation, spending his time interacting with and supporting the community in many ways, often away from public view. Through personal sacrifices, José has allowed the Haskell Foundation to ...

HaskellOrg
@haskell@fosstodon.org

The Ultimate Functional Programming Humble Bundle features two excellent books by Rebecca Skinner

* Effective Haskell
* Haskell Brain Teasers

Check it out! humblebundle.com/books/ultimat

humblebundle.com

Humble Tech Book Bundle: The Ultimate Functional Programming by Pragmatic Programmers

Pay what you want for a curated collection of functional programming courses by Pragmatic Programmers and help support Save the Children with your purchase!

Abhinav 🧭
@abnv@fantastic.earth

In an alternative timeline where is the norm instead of Object-oriented programming, and is the most popular instead of , there is a list of tutorials trying to explain what Objects are to programmers in terms of FP concepts, the most popular of which is, “Objects are Comonads”.

However, we don't live in that timeline, so we'll have to be content with the inverse article, “Comonads are Objects” haskellforall.com/2013/02/you- .

haskellforall.com

Comonads are objects

Haskell programmers popularized the use of monads to structure imperative computations, complete with syntactic sugar in the form of do not...

Abhinav 🧭
@abnv@fantastic.earth

Wrote some in as an using the Clay library. Gotta say, writing type-safe CSS is a really nice experience.

```haskell
pageStyle = do
body ? do
header ? do
textAlign center
main_ ** article ? do
small ? do
fontSize $ em 0.5
marginLeft $ em 0.3
".meta" ? do
display flex
justifyContent spaceBetween
ul # ".tags" ? do
paddingLeft $ em 0
li ? do
display inlineBlock
backgroundColor $ rgb 230 230 250
color $ rgb 34 34 34
margin (em 0.2) (em 0.1) (em 0.2) (em 0.1)
padding (em 0.1) (em 0.5) (em 0.1) (em 0.5)
whiteSpace nowrap
fontSizeCustom smaller
query CM.screen [CM.prefersColorScheme CM.dark] $ do
backgroundColor $ rgb 72 57 165
color $ rgb 217 216 220
footer ? do
textAlign center
fontSizeCustom smaller
borderTop 1 dashed black
```

Patrik Jansson
@patrikja@functional.cafe

In January 2027, I will teach the first instalment of the new BSc course "Functional Programming: continuation course" (joint between Chalmers and UGOT). share.google/int8wna1Pjo9T1tGE
Within a month or so, I need to decide on the course literature. I'd be very happy to receive thoughts, suggestions, warnings, etc. about what you think would work, or not.
More details below:

Learning outcomes:
Knowledge and understanding:

+ Explain and apply fundamental abstractions in functional programming, including lazy/strict evaluation, functors, & monads, and describe how these abstractions can be used to handle state, exceptions, and I/O in a purely functional way.
+ Explain how algebraic properties such as associativity and commutativity enable divide-and-conquer and parallel evaluation in pure functional programs, and discuss how purity and referential transparency support the design of compositional embedded domain-specific languages (EDSLs).

Skills and abilities:

+ Design, structure, and implement functional programs and small EDSLs using appropriate type classes, algebraic operators, and data structures for efficient and, where appropriate, parallel computation.
+ Apply functional techniques such as recursion schemes, memoization, and algebraic composition to implement and reason about non-trivial algorithms.
+ Use relevant tools and libraries to develop, test, and document maintainable programs, including performance analysis and identification of common inefficiencies.
+ Structure and solve real-world programming problems in a functional style, integrating abstraction, testing, and reasoning for correctness and efficiency.

Judgement and approach:

+ Critically assess the suitability of abstractions and algebraic structures for specific programming problems, through reflection on the trade-offs between abstraction, performance, and resource use.
+ Evaluate program design decisions and correctness using property-based testing, algebraic properties, and equational reasoning.
+ Demonstrate responsibility in program design and collaboration, ensuring modularity, clear documentation, and maintainability.

chalmers.se

Functional Programming: continuation course

HaskellOrg
@haskell@fosstodon.org

"linear-locks: locking primitives free of deadlocks"

If you encounter STM's limitations when it comes to lock-free synchronisation, then Linear Haskell-backed locks maybe the solution you want!

discourse.haskell.org/t/ann-li

discourse.haskell.org

[ANN] linear-locks: locking primitives free of deadlocks

linear-locks provides locking primitives that are statically guaranteed not to lead to deadlocks. It achieves this by breaking one of the Coffman conditions for deadlocks: the “circular wait” condition. linear-locks ensures locks are always acquired in a consistent order. tl;dr: Each lock is assigned a “level”, tracked at the type level. When you enter a “lock scope”, you’re given a key that can acquire locks of level 0 or above. When you acquire a lock of level n, the key is consumed and you’...

Patrik Jansson
@patrikja@functional.cafe

In January 2027, I will teach the first instalment of the new BSc course "Functional Programming: continuation course" (joint between Chalmers and UGOT). share.google/int8wna1Pjo9T1tGE
Within a month or so, I need to decide on the course literature. I'd be very happy to receive thoughts, suggestions, warnings, etc. about what you think would work, or not.
More details below:

Learning outcomes:
Knowledge and understanding:

+ Explain and apply fundamental abstractions in functional programming, including lazy/strict evaluation, functors, & monads, and describe how these abstractions can be used to handle state, exceptions, and I/O in a purely functional way.
+ Explain how algebraic properties such as associativity and commutativity enable divide-and-conquer and parallel evaluation in pure functional programs, and discuss how purity and referential transparency support the design of compositional embedded domain-specific languages (EDSLs).

Skills and abilities:

+ Design, structure, and implement functional programs and small EDSLs using appropriate type classes, algebraic operators, and data structures for efficient and, where appropriate, parallel computation.
+ Apply functional techniques such as recursion schemes, memoization, and algebraic composition to implement and reason about non-trivial algorithms.
+ Use relevant tools and libraries to develop, test, and document maintainable programs, including performance analysis and identification of common inefficiencies.
+ Structure and solve real-world programming problems in a functional style, integrating abstraction, testing, and reasoning for correctness and efficiency.

Judgement and approach:

+ Critically assess the suitability of abstractions and algebraic structures for specific programming problems, through reflection on the trade-offs between abstraction, performance, and resource use.
+ Evaluate program design decisions and correctness using property-based testing, algebraic properties, and equational reasoning.
+ Demonstrate responsibility in program design and collaboration, ensuring modularity, clear documentation, and maintainability.

chalmers.se

Functional Programming: continuation course

HaskellOrg
@haskell@fosstodon.org

hpgsql, a PostgreSQL driver written in pure

discourse.haskell.org/t/ann-hp

discourse.haskell.org

[ANN] hpgsql, a pure Haskell PostgreSQL driver (no libpq)

It’s a pleasure to announce hpgsql, a PostgreSQL driver written in pure Haskell (no libpq), with an API largely inspired by the great postgresql-simple library, but featuring: Usage of PostgreSQL’s binary protocol Query arguments passed via the protocol instead of being escaped into the query string Pipelining Prepared statements Ability to stream query results directly from the socket (not just with cursors) Interruption safety, except for very specific (and documented) edge cases Thread safe...

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared May 9, 2026. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared May 9, 2026

The readings shared in Bluesky on 9 May 2026 are: A shallow embedding of Datalog in Lean. ~ Ramy Shahin. #LeanProver #ITP Bennett's conjecture in Lean 4: Counter-models for the PSR-reducibility of Sp

Brent Yorgey
@byorgey@mathstodon.xyz

I wanted a function to efficiently compute the conjugate of an integer partition. I think I know how to write it, but it's fiddly. There's a nice, succinct functional specification:

conjugate = reverse . map length . transpose . map (`replicate` ())

but it's slow. Now I'm wondering whether it's possible to derive an efficient version from this specification, -Meertens style. Anyone know of previous work along these lines? Or should I add it to my list of interesting projects?

HaskellOrg
@haskell@fosstodon.org

You can now try MicroHS in the browser! Check it out:

augustss.github.io/MicroHs/web

Discourse: discourse.haskell.org/t/microh

discourse.haskell.org

MicroHs in the browser

You can now run interactive mhs in your browser. Try it! It currently only has the base package included, but it is trivial to make a version that has arbitrary packages (well, those that mhs can compile) embedded in the system. The site consist of a small index.html (4K) and a rather hefty mhs-embed.js (2.3M). The latter contains the compiler, runtime system, and base package. It is built by emscripten to compile the C code to JS and Wasm. Currently, you cannot access the local file syste...

HaskellOrg
@haskell@fosstodon.org

You can now try MicroHS in the browser! Check it out:

augustss.github.io/MicroHs/web

Discourse: discourse.haskell.org/t/microh

discourse.haskell.org

MicroHs in the browser

You can now run interactive mhs in your browser. Try it! It currently only has the base package included, but it is trivial to make a version that has arbitrary packages (well, those that mhs can compile) embedded in the system. The site consist of a small index.html (4K) and a rather hefty mhs-embed.js (2.3M). The latter contains the compiler, runtime system, and base package. It is built by emscripten to compile the C code to JS and Wasm. Currently, you cannot access the local file syste...

HaskellOrg
@haskell@fosstodon.org

The Tokyo Meetup will happen on the 19th of May with speakers Luite Stegeman and Farhad Mehta

Discourse: discourse.haskell.org/t/haskel

Meetup: meetup.com/tokyo-haskell-meetu

meetup.com

Haskell: DevTools and Generic Hoogle, Tue, May 19, 2026, 6:20 PM | Meetup

Join us for an exciting evening of Haskell discussions in Tokyo! We're thrilled to welcome **Luite Stegeman** and **Elliot Potts** as speakers. **Talks** (English): **The

HaskellOrg
@haskell@fosstodon.org

The Lambda Nantes Meetup will happen on the 21st of May, with speakers @clementd and @etorreborre as speakers

discourse.haskell.org/t/lambda

 

discourse.haskell.org

Lambda Nantes Meetup - 21 May

Hello, The Lambda Nantes Meetup is back in May, the 21st, with not one but TWO talks: Clément Delafargue (@clementd.wtf) will demonstrate that everything boils down to traverse Eric Torreborre (@etorreborre.bloh) will share some new ideas about Compositional Programming Please note that talks will be in French 🇫🇷 ! Registration and location/time details on Mobilizon: Programmation compositionnelle et traversabilité - Mobilizon Lambda Nantes is not a Haskell-only meetup, it’s dedicate...

Fraser Tweedale
@hackuador@functional.cafe

Brisbane Functional Programming Group May 12: Tim Lamberton will teach us about data type derivatives and zippers, and Carlo will introduce Datastar, his new framework for interactive web apps. Be there or a be a lambda cube! luma.com/72tqx0nh

luma.com

BFPG Meetup - May 2026 - zippers + the Datastar framework · Luma

Join the BFPG Discord: https://discord.gg/yYz2d8w7FY Agenda 18:00: Welcome and setup Presentation #1: What is the derivative of a data type? - Tim…

HaskellOrg
@haskell@fosstodon.org

The Paris Spring Meetup will happen on the 27th of May at ENS Ulm.

See the announcement here: discourse.haskell.org/t/haskel

Register here: meetup.com/haskell-paris/event

meetup.com

Haskell Paris Spring Meetup, Wed, May 27, 2026, 7:30 PM | Meetup

(English 🇮🇪 below) Le meetup Haskell parisien reviens pour le printemps en partenariat avec HackENS, le hackerspace de l'ENS Ulm. Cela sera l'occasion de se revoir, par

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared May 5, 2026. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared May 4, 2026

The readings shared in Bluesky on 4 May 2026 are: Compfiles: Catalog of math problems formalized in Lean. ~ David Renshaw et als. #LeanProver #ITP #Math Primitive pythagorean triples in lean and redu

HaskellOrg
@haskell@fosstodon.org

Pure Borrow: Linear Meets -Style Borrowing

Announcement post:
discourse.haskell.org/t/pure-b

First release on Hackage: discourse.haskell.org/t/ann-pu

discourse.haskell.org

[ANN] pure-borrow-0.0.0.0

We are pleased to announce the first release of Pure Borrow: Linear Haskell Meets Rust-Style Borrowing 🎉 Although the implementation is in somewhat usable stage, but it is still under heavy development. See the previous post on Discourse for the detailed explanation. This release covers API described in our original paper, plus some experimental feature like record borrow splitting or generalized reborrows. Feeedbacks are always welcome! Happy Linear Haskelling! 🍭

HaskellOrg
@haskell@fosstodon.org

Pure Borrow: Linear Meets -Style Borrowing

Announcement post:
discourse.haskell.org/t/pure-b

First release on Hackage: discourse.haskell.org/t/ann-pu

discourse.haskell.org

[ANN] pure-borrow-0.0.0.0

We are pleased to announce the first release of Pure Borrow: Linear Haskell Meets Rust-Style Borrowing 🎉 Although the implementation is in somewhat usable stage, but it is still under heavy development. See the previous post on Discourse for the detailed explanation. This release covers API described in our original paper, plus some experimental feature like record borrow splitting or generalized reborrows. Feeedbacks are always welcome! Happy Linear Haskelling! 🍭

see shy jo
@joeyh@sunbeam.city

Wow, it's been too long since I read a really good blog post.

blog.haskell.org/a-couple-mill

Putting this away to enjoy later, I was up at 6 am working out how to winch a huge hot water heater from a pickup truck onto my porch. Which we succeeded at eventually..

blog.haskell.org

A Couple Million Lines of Haskell: Production Engineering at Mercury | The Haskell Programming Language's blog

What it takes to run 2 million lines of Haskell in production at a fintech company serving 300,000 businesses.

see shy jo
@joeyh@sunbeam.city

Wow, it's been too long since I read a really good blog post.

blog.haskell.org/a-couple-mill

Putting this away to enjoy later, I was up at 6 am working out how to winch a huge hot water heater from a pickup truck onto my porch. Which we succeeded at eventually..

blog.haskell.org

A Couple Million Lines of Haskell: Production Engineering at Mercury | The Haskell Programming Language's blog

What it takes to run 2 million lines of Haskell in production at a fintech company serving 300,000 businesses.

see shy jo
@joeyh@sunbeam.city

Wow, it's been too long since I read a really good blog post.

blog.haskell.org/a-couple-mill

Putting this away to enjoy later, I was up at 6 am working out how to winch a huge hot water heater from a pickup truck onto my porch. Which we succeeded at eventually..

blog.haskell.org

A Couple Million Lines of Haskell: Production Engineering at Mercury | The Haskell Programming Language's blog

What it takes to run 2 million lines of Haskell in production at a fintech company serving 300,000 businesses.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

A monadic implementation of functional logic programs. ~ Michael Hanus, Kai-Oliver Prott, Finn Teegen. arxiv.org/abs/2604.27863v1

arxiv.org

A Monadic Implementation of Functional Logic Programs

Functional logic languages are a high-level approach to programming by combining the most important declarative features. They abstract from small-step operational details so that programmers can concentrate on the logical aspects of an application. This is supported by appropriate evaluation strategies. Demand-driven evaluation from functional programming is amalgamated with non-determinism from logic programming so that solutions or values are computed whenever they exist. This frees the programmer from considering the influence of an operational strategy on the success of a computation, but it is a challenge to the language implementer. A non-deterministic demand-driven strategy might duplicate unevaluated choices of an expression, which could duplicate the computational effort. In recent implementations, this problem has been tackled by adding a kind of memoization of non-deterministic choices to the expression under evaluation. Since this has been implemented in imperative target languages, it was unclear whether this could also be supported in a functional programming environment like Haskell. This paper presents a solution to this challenge by transforming functional logic programs into a monadic representation. Although this transformation is not new, we present an implementation of the monadic interface which supports memoization in non-deterministic branches. Additionally, we include more advanced features of functional logic languages, namely functional patterns and encapsulated search, in our approach. By optimizing our implementation for purely functional computations with both a static and dynamic approach, we are able to achieve a promising performance that outperforms current compilers for Curry.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Arboretum.hs: Symbolic manipulation for algebras of graphs. ~ Eugen Bronasco, Jean-Luc Falcone, Gilles Vilmart. arxiv.org/abs/2604.25879v1

arxiv.org

Arboretum.hs: Symbolic manipulation for algebras of graphs

We design the Arboretum$.$hs package for symbolic computations with algebras of trees and more general graphs in Haskell. Thanks to the declarative nature of functional programming, the package's implementation closely follows mathematical definitions, making the code intuitive and transparent for users working with algebraic and combinatorial structures. To assist with current mathematical research, Arboretum$.$hs supports experimentation by facilitating the introduction of new algebraic operations, as well as providing functionality for rendering trees and forests through LaTeX integration. Compared to recent imperative implementations in languages such as Julia or Python, Arboretum$.$hs offers greater flexibility for manipulating and extending tree-based structures. Its use of Haskell enables safe programming and strong compile-time guarantees, serving both as a practical computational tool and a foundation for further research in algebraic combinatorics, beyond the setting of trees usually considered in the implementation of Butcher series, which are a fundamental tool for the analysis of numerical integrators.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared April 29, 2026. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared April 29, 2026

The readings shared in Bluesky on 29 April 2026 are: A Lean companion to «Conceptual mathematics». ~ David Kinkead. #LeanProver #ITP #Math A milestone in formalization: The sphere packing problem in

Abhinav 🧭
@abnv@fantastic.earth

Would people be interested in a series of posts where I implement the C from "Writing a C Compiler" book by Nora Sandler in ? I'd focus on Haskell specific libraries and techniques with some additional bits not present in the book.

  • Yes21 (84%)
  • No3 (12%)
  • I hate book implementations1 (4%)
Lobsters
@lobsters@mastodon.social

Torsten Grust on The Haskell Interlude lobste.rs/s/eliuli
haskell.foundation/podcast/81/

haskell.foundation

Torsten Grust

Mike and Andres sat down with Torsten Grust, who is a professor of DB systems at the University of Tübingen. Even though Torsten loves SQL, he's used functional programming and Haskell to inform his work on query language design and compilation. We talked about the best way to program databases, how to bridge the gap between regular programming languages and databases, and compiling just about everything to SQL.

HaskellOrg
@haskell@fosstodon.org

Maybe there is a nuanced discussion to have about using LLMs to write , but it cannot happen before crawlers stop DDOSing the Haskell Gitlab instance. 😬

DiazCarrete
@DiazCarrete@hachyderm.io

Pure Borrow: Linear Haskell Meets Rust-Style Borrowing discourse.haskell.org/t/pure-b

discourse.haskell.org

Pure Borrow: Linear Haskell Meets Rust-Style Borrowing

TL;DR You can now use Rust-style mutable and shared borrows in Linear Haskell, within ST-like linear monad, BO, with pure, type-safe, and leak-freedom support of mutation and concurrency! It comes with flexible feature of multiple aliasing of shared borrows, delimiting lifetime regions, etc! We are really pleased to announce the acceptance of our work, Pure Borrow, at PLDI 2026 🎉 Paper (Extended Version): [2604.15290] Pure Borrow: Linear Haskell Meets Rust-Style Borrowing Implementation:...

DiazCarrete
@DiazCarrete@hachyderm.io

Botan: Project Recap and Major Ergonomics Changes discourse.haskell.org/t/botan-

discourse.haskell.org

Botan bindings devlog

Botan: Project Recap and Major Ergonomics Changes I have been a little quiet on the forums, and you know what that means - I’ve been working on something sizeable, and all my energy has been put towards ‘doing’ rather than ‘talking’. I do tend to cycle between focuses, it helps keep things interestnig, and stops me from getting too far into the weeds, as I am often wont to do. This last month’s focus has been botan, and I am happy to report some significant progress. A quick summary, I’d estima...

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared April 24, 2026. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared April 24, 2026

The readings shared in Bluesky on 24 April 2026 are: Deep Vision: A formal proof of Wolstenholmes theorem in Lean 4. ~ Alexandre Linhares. #LeanProver #ITP #AI4Math Discover and prove: An open-source

Lobsters
@lobsters@mastodon.social

Pure Borrow: Linear Haskell Meets Rust-Style Borrowing lobste.rs/s/esidgp
discourse.haskell.org/t/pure-b

discourse.haskell.org

Pure Borrow: Linear Haskell Meets Rust-Style Borrowing

TL;DR You can now use Rust-style mutable and shared borrows in Linear Haskell, within ST-like linear monad, BO, with pure, type-safe, and leak-freedom support of mutation and concurrency! It comes with flexible feature of multiple aliasing of shared borrows, delimiting lifetime regions, etc! We are really pleased to announce the acceptance of our work, Pure Borrow, at PLDI 2026 🎉 Paper (Extended Version): [2604.15290] Pure Borrow: Linear Haskell Meets Rust-Style Borrowing Implementation:...

HaskellOrg
@haskell@fosstodon.org

Pure Borrow: Linear Meets -Style Borrowing

discourse.haskell.org/t/pure-b

discourse.haskell.org

Pure Borrow: Linear Haskell Meets Rust-Style Borrowing

TL;DR You can now use Rust-style mutable and shared borrows in Linear Haskell, within ST-like linear monad, BO, with pure, type-safe, and leak-freedom support of mutation and concurrency! It comes with flexible feature of multiple aliasing of shared borrows, delimiting lifetime regions, etc! We are really pleased to announce the acceptance of our work, Pure Borrow, at PLDI 2026 🎉 Paper (Extended Version): [2604.15290] Pure Borrow: Linear Haskell Meets Rust-Style Borrowing Implementation:...

Andres Löh
@kosmikus@functional.cafe

After a somewhat longer break, we're finally back with a new episode. Tomorrow, 2026-04-22, at 18:30 UTC, Edsko and I will talk about selective applicative functors. youtube.com/watch?v=Yt2E1vrgP_

youtube.com

Not quite monads (Haskell Unfolder #54)

Monads are a very powerful abstraction: sometimes too powerful. We discusswhy we might not always want the full generality of monads, and what we canuse inst...

Lobsters
@lobsters@mastodon.social

Optimizing xreferee with elemIndex lobste.rs/s/uxjpyz
brandonchinn178.github.io/post

brandonchinn178.github.io

Optimizing xreferee with elemIndex

xreferee is a linter that checks that every @(ref:foo) reference in a git repository corresponds to a #(ref:foo) anchor somewhere in the repository. It delegates most of the search to git grep, but there's some parsing logic to parse git grep's output. In a recent PR, I was able to get a 5x speedup with two changes:

claude
@mathr@post.lurk.org

remembering that time I tried to implement arbitrary precision arithmetic in with precision in the type, only some operations actually used higher precision before rounding. the resulting unbounded recursion led to a heap profile graph that was an ever growing wedge of Num dictionary until heap exhaustion (and nothing worked).

Abhinav 🧭
@abnv@fantastic.earth

JSON is probably the most used standard file format for storing and transmitting data on the Internet in recent times. It has a simple syntax with only four scalar data types and two composite data types. So, writing a parser for is a great exercise for learning the basics of parsing.

That's exactly what I did: I wrote a JSON from scratch in . Read my post to learn about basics of parsing, nuances of the JSON syntax, and parser combinators and property-based in Haskell: abhinavsarkar.net/posts/json-p

A transition diagram depicting the JSON syntax.
ALT text

A transition diagram depicting the JSON syntax.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared April 14, 2026. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared April 14, 2026

The readings shared in Bluesky on 14 April 2026 are: A formal proof of the Ramanujan-Nagell theorem in Lean 4. ~ Barinder S. Banwait. #LeanProver #ITP #AI4Math Formalization of De Giorgi-Nash-Moser t

Lobsters
@lobsters@mastodon.social

Single Module Lambda Calculus from Simply Typed to Martin Lof Type Theory lobste.rs/s/fwvw1q
github.com/solomon-b/lambda-ca

github.com

GitHub - solomon-b/lambda-calculus-hs: Single file Lambda Calculus implementations demonstrating various type system features and interpretation techniques

Single file Lambda Calculus implementations demonstrating various type system features and interpretation techniques - solomon-b/lambda-calculus-hs

HaskellOrg
@haskell@fosstodon.org

Imagine being able to install binary distributions of your favourite tools:

$ ghcup install pandoc
$ ghcup install hlint
$ ghcup install fourmolu
$ ghcup install shellcheck

Well, imagine no more! GHCup 0.2.0.0 will bring a new installer DSL to allow third-party projects to maintain their distribution channel! The more feedback the better!

Try it out at discourse.haskell.org/t/ann-gh

discourse.haskell.org

[ANN] GHCup 0.2.0.0 RC (or beta, maybe)

This is maybe more of a BETA than a RELEASE CANDIDATE, but anyway. With support from IOG, I have implemented some form of Intaller DSL · Issue #141 · haskell/ghcup-hs · GitHub It’s not really a DSL though, but rather an “install specification”. That means GHCup can now install arbitrary tools. This moved us a bit on the “installer vs package manager” design spectrum. But it’s still an installer (for several reasons). How to test You may want to back up your ~/.ghcup directory, especially if y...

HaskellOrg
@haskell@fosstodon.org

Imagine being able to install binary distributions of your favourite tools:

$ ghcup install pandoc
$ ghcup install hlint
$ ghcup install fourmolu
$ ghcup install shellcheck

Well, imagine no more! GHCup 0.2.0.0 will bring a new installer DSL to allow third-party projects to maintain their distribution channel! The more feedback the better!

Try it out at discourse.haskell.org/t/ann-gh

discourse.haskell.org

[ANN] GHCup 0.2.0.0 RC (or beta, maybe)

This is maybe more of a BETA than a RELEASE CANDIDATE, but anyway. With support from IOG, I have implemented some form of Intaller DSL · Issue #141 · haskell/ghcup-hs · GitHub It’s not really a DSL though, but rather an “install specification”. That means GHCup can now install arbitrary tools. This moved us a bit on the “installer vs package manager” design spectrum. But it’s still an installer (for several reasons). How to test You may want to back up your ~/.ghcup directory, especially if y...

HaskellOrg
@haskell@fosstodon.org

Any appetite in the crowd for "A CTO's Guide to Adopting "? If so, there would be things like:

* Observability
* Domain Design
* Just Enough Haskell To Be Dangerous™
* Library recommendations for your HTTP/gRPC/DB needs
* SBOM

What else would you like to see?

meejah
@meejah@mastodon.social · Reply to David Reed

@aoristdual yeah .. on the flip side, the documentation is really good in general and the compiler gives very good hints and error messages (in general).

I don't think I would have succeeded at any (or ) learning without IDE support -- these languages are what made me make LSP work correctly, finally :)

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Type-level programming is still programming. ~ Michael Chavinda. mchav.github.io/type-level-pro

mchav.github.io

Type-level programming is still programming

I was showing a friend the typed dataframe API. The whole pitch was: look, you derive a schema from your data, and then the compiler catches column name typos, type mismatches, all the stuff that would otherwise blow up at runtime. I had a nice demo ready using the Kaggle credit card fraud dataset (about 284,000 rows, 31 columns).

claude
@mathr@post.lurk.org

remembering that time I tried to implement arbitrary precision arithmetic in with precision in the type, only some operations actually used higher precision before rounding. the resulting unbounded recursion led to a heap profile graph that was an ever growing wedge of Num dictionary until heap exhaustion (and nothing worked).

Abhinav 🧭
@abnv@fantastic.earth

Comparing the chart of tutorials by year[1] with the Gartner hype cycle graph, it seems like we are almost at the Peak of Inflated Expectations phase now.

[1]: From the list of Monad tutorials (wiki.haskell.org/Monad_tutoria).

In my lifetime, I hope to see the Slope of Enlightenment phase when people stop asking what a Monad is, and the further Plateau of Productivity phase when everyone knows what it is.

A line chart showing number of Monad tutorials published yearly from 1990 to 2023. The number grows slowly at the beginning, then rises sharply starting 2015, then seems to plateau around 2022.
ALT text

A line chart showing number of Monad tutorials published yearly from 1990 to 2023. The number grows slowly at the beginning, then rises sharply starting 2015, then seems to plateau around 2022.

The graph of the Gartner Hype Cycle.
ALT text

The graph of the Gartner Hype Cycle.

Abhinav 🧭
@abnv@fantastic.earth · Reply to Abhinav 🧭

I finished Make A in C++20 in about 2600 lines of code. I learned a lot about modern and managed to write the whole without writing a single C-style macro or pointer arithmetic or type casting.

Compared to my usual choice , C++ is way more verbose. I feel I can write the same interpreter in (idiomatic) Haskell in less than 800 LOCs. But it’ll probably be much slower.

Some time later in the year, I want to attempt writing a compiler for MAL in Haskell via QBE.

Abhinav 🧭
@abnv@fantastic.earth

I wrote the third part of my post series: “Implementing Co, a Small Language With Coroutines #3: Adding ”. abhinavsarkar.net/posts/implem

Reply to this toot to post comments on the article.

abhinavsarkar.net

Implementing Co, a Small Language With Coroutines #3: Adding Coroutines

We implement Co, a small language with coroutines and channels.

michabbb
@michabbb@vivaldi.net · Reply to michabbb

🚀 Performance on a completely different level:

Written in with the Warp HTTP server. JSON gets serialized directly in SQL. Connection pooling via Hasql. Subsecond response times at 2000 req/sec — even on free tier hosting.

🔐 Security is built in, not bolted on:
Auth runs via JWT. Authorization is controlled directly in the database through roles. One single declarative source of truth for security. The server assumes the identity of the authenticated user.

Jaro Reinders
@jaror@social.edu.nl

Might 9.14 be the first release that does not break anything (except for bounds bumps)? If you find anything, report it here:

discourse.haskell.org/t/was-an

discourse.haskell.org

Was any breakage caused by 9.14?

Did anyone’s build break when they updated to GHC 9.14? That is, was any non-trival (not just bound bumps) change required to upgrade Haskell code that worked with GHC 9.12 to GHC 9.14? I haven’t found any examples but it’s possible I haven’t been paying close enough attention. For the last coupule of years I’ve been keeping a breakage inventory of such breakage. The amount of breakage has been declining over that period. Has it really hit zero? If you know of some such breakage please let me...

Jaro Reinders
@jaror@social.edu.nl

Might 9.14 be the first release that does not break anything (except for bounds bumps)? If you find anything, report it here:

discourse.haskell.org/t/was-an

discourse.haskell.org

Was any breakage caused by 9.14?

Did anyone’s build break when they updated to GHC 9.14? That is, was any non-trival (not just bound bumps) change required to upgrade Haskell code that worked with GHC 9.12 to GHC 9.14? I haven’t found any examples but it’s possible I haven’t been paying close enough attention. For the last coupule of years I’ve been keeping a breakage inventory of such breakage. The amount of breakage has been declining over that period. Has it really hit zero? If you know of some such breakage please let me...

Abhinav 🧭
@abnv@fantastic.earth

I wrote the fifth part of my series “Implementing Co, a small programming language with ”. This time, we add support for sleep in for time-based executions. abhinavsarkar.net/posts/implem

abhinavsarkar.net

Implementing Co, a Small Language With Coroutines #5: Adding Sleep

We implement Co, a small language with coroutines and channels.

DiazCarrete
@DiazCarrete@hachyderm.io

Rethinking Typed Template Haskell gitlab.haskell.org/ghc/ghc/-/w discourse.haskell.org/t/ghc-co

discourse.haskell.org

GHC community update March 2026

Thank you for the positive feedback on our last post. The GHC community update consists of three sections: Call for contributions: The GHC team asks for contributions - these range from issues that are simple and fun to solve to issues that require an expert pair of eyes that we have too few of. Call for opinions: The GHC team asks for your opinion on some matter regarding GHC - these are issues about often contentious matters where community input is highly valued. We ask that you engage in ...

HaskellOrg
@haskell@fosstodon.org

GHC community update March 2026
by @mangoiv

discourse.haskell.org/t/ghc-co

discourse.haskell.org

GHC community update March 2026

Thank you for the positive feedback on our last post. The GHC community update consists of three sections: Call for contributions: The GHC team asks for contributions - these range from issues that are simple and fun to solve to issues that require an expert pair of eyes that we have too few of. Call for opinions: The GHC team asks for your opinion on some matter regarding GHC - these are issues about often contentious matters where community input is highly valued. We ask that you engage in ...

Su-Shee
@sushee@ohai.social

some wise words about operations and reliability in this blog.haskell.org/a-couple-mill article which basically isn't even really about haskell

(it's really good you know the stuff we liked before and then bookmarked it even)

blog.haskell.org

A Couple Million Lines of Haskell: Production Engineering at Mercury | The Haskell Programming Language's blog

What it takes to run 2 million lines of Haskell in production at a fintech company serving 300,000 businesses.

Fraser Tweedale
@hackuador@functional.cafe

Brisbane Functional Programming Group April meetup, Tue 14th. Jack will present about using with Lambda. And we will have a Hack Day review where people will demo or share what they did at Hack Day. Be there or be a lambda cube!

luma.com/cjlche2l

luma.com

BFPG Meetup - April 2026 - Haskell on AWS Lambda + Hack Day retro · Luma

Join the BFPG Discord: https://discord.gg/yYz2d8w7FY Agenda 18:00: Welcome and setup Presentation #1: Lambda on Lambda: Running Haskell on AWS's…

Fraser Tweedale
@hackuador@functional.cafe

Brisbane Functional Programming Group April meetup, Tue 14th. Jack will present about using with Lambda. And we will have a Hack Day review where people will demo or share what they did at Hack Day. Be there or be a lambda cube!

luma.com/cjlche2l

luma.com

BFPG Meetup - April 2026 - Haskell on AWS Lambda + Hack Day retro · Luma

Join the BFPG Discord: https://discord.gg/yYz2d8w7FY Agenda 18:00: Welcome and setup Presentation #1: Lambda on Lambda: Running Haskell on AWS's…

Su-Shee
@sushee@ohai.social

some wise words about operations and reliability in this blog.haskell.org/a-couple-mill article which basically isn't even really about haskell

(it's really good you know the stuff we liked before and then bookmarked it even)

blog.haskell.org

A Couple Million Lines of Haskell: Production Engineering at Mercury | The Haskell Programming Language's blog

What it takes to run 2 million lines of Haskell in production at a fintech company serving 300,000 businesses.

HaskellOrg
@haskell@fosstodon.org

The editors of the Blog are happy to announce a new series of articles called "Haskellers from the trenches", where we invite experienced engineers to talk about their subjects of expertise, best practices, and production tales.

Our first guest is @iankduncan.com with "A Couple Million Lines of Haskell: Production Engineering at Mercury"

blog.haskell.org/a-couple-mill

blog.haskell.org

A Couple Million Lines of Haskell: Production Engineering at Mercury | The Haskell Programming Language's blog

What it takes to run 2 million lines of Haskell in production at a fintech company serving 300,000 businesses.

Abhinav 🧭
@abnv@fantastic.earth

I'm writing a series of blog posts, in which I write a and a for arithmetic in . We explore the following topics in the series:

- Parsing arithmetic expressions to ASTs.
- Compiling ASTs to bytecode.
- Interpreting ASTs.
- Efficiently executing bytecode in a VM.
- Disassembling bytecode and decompiling opcodes for debugging and testing.
- Unit testing and property-based testing for our compiler and VM.
- Benchmarking our code to see how the different passes perform.
- All the while keeping an eye on performance.

The second post of the series that focuses on writing the is now out: abhinavsarkar.net/posts/arithm

abhinavsarkar.net

A Fast Bytecode VM for Arithmetic: The Compiler

We write a fast bytecode VM for arithmetic in Haskell.

DiazCarrete
@DiazCarrete@hachyderm.io

"Compiler and runtime support for continuation marks" (PLDI 2020) dl.acm.org/doi/10.1145/3385412
"Continuation marks enable dynamic binding and context inspection in a language with proper handling of tail calls and first-class, multi-prompt, delimited continuations."

GHC proposal: "scoped thread-locals" github.com/ghc-proposals/ghc-p
"efficient storage and lookup for immutable context
attached to the current Haskell thread, which is inherited by child threads."

github.com

scoped thread-locals proposal by edmundnoble · Pull Request #751 · ghc-proposals/ghc-proposals

This is a proposal for introducing scoped thread-locals into GHC Haskell. Scoped thread-locals provide efficient storage and lookup for immutable context attached to the current Haskell thread, whi...

Fraser Tweedale
@hackuador@functional.cafe

Added a new recipe to my grimoire: frasertweedale.github.io/blog-

frasertweedale.github.io

Generating Hakyll pages from Haskell source

In typical use, Hakyll programs convert external content files into HTML pages. But what if your content is defined in Haskell source files that are part of the Hakyll program? That can work—but you need a trick or two. In this post I’ll show you how.

Fraser Tweedale
@hackuador@functional.cafe

Added a new recipe to my grimoire: frasertweedale.github.io/blog-

frasertweedale.github.io

Generating Hakyll pages from Haskell source

In typical use, Hakyll programs convert external content files into HTML pages. But what if your content is defined in Haskell source files that are part of the Hakyll program? That can work—but you need a trick or two. In this post I’ll show you how.

Fraser Tweedale
@hackuador@functional.cafe

Two more sleeps until the first Hack Day of 2026! See yas there, curious minds!

functional.cafe

Fraser Tweedale (@hackuador@functional.cafe)

Functional programmers and #FP curious people in Brisbane: don't miss #BFPG Hack Day this Saturday 28 March at UQ: https://luma.com/uu28az9h

Shane Celis
@shanecelis@mastodon.gamedev.place

“I have no IO monad and I must scream.”

“Sorry. Emitting heat is the best I can do.”

CUSTOMER: I have no IO monad and I must scream. PAWN SHOP GUYS: Sorry. Emitting heat is the best I can do.
ALT text

CUSTOMER: I have no IO monad and I must scream. PAWN SHOP GUYS: Sorry. Emitting heat is the best I can do.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared March 24, 2026. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared March 24, 2026

The readings shared in Bluesky on 24 March 2026 are: Synthetic differential geometry in Lean. ~ Riccardo Brasca, Gabriella Clemente. #LeanProver #ITP #Math The spectral comb and the Riemann hypothesi

Shane Celis
@shanecelis@mastodon.gamedev.place

“I have no IO monad and I must scream.”

“Sorry. Emitting heat is the best I can do.”

CUSTOMER: I have no IO monad and I must scream. PAWN SHOP GUYS: Sorry. Emitting heat is the best I can do.
ALT text

CUSTOMER: I have no IO monad and I must scream. PAWN SHOP GUYS: Sorry. Emitting heat is the best I can do.

Shane Celis
@shanecelis@mastodon.gamedev.place

“I have no IO monad and I must scream.”

“Sorry. Emitting heat is the best I can do.”

CUSTOMER: I have no IO monad and I must scream. PAWN SHOP GUYS: Sorry. Emitting heat is the best I can do.
ALT text

CUSTOMER: I have no IO monad and I must scream. PAWN SHOP GUYS: Sorry. Emitting heat is the best I can do.

Abhinav 🧭
@abnv@fantastic.earth

I wrote the fourth part of my series “Implementing Co, a small programming language with ”. And this time, we add support for channels in for inter-coroutine communication. abhinavsarkar.net/posts/implem

abhinavsarkar.net

Implementing Co, a Small Language With Coroutines #4: Adding Channels

We implement Co, a small language with coroutines and channels.

Shane Celis
@shanecelis@mastodon.gamedev.place

“I have no IO monad and I must scream.”

“Sorry. Emitting heat is the best I can do.”

CUSTOMER: I have no IO monad and I must scream. PAWN SHOP GUYS: Sorry. Emitting heat is the best I can do.
ALT text

CUSTOMER: I have no IO monad and I must scream. PAWN SHOP GUYS: Sorry. Emitting heat is the best I can do.

Shane Celis
@shanecelis@mastodon.gamedev.place

“I have no IO monad and I must scream.”

“Sorry. Emitting heat is the best I can do.”

CUSTOMER: I have no IO monad and I must scream. PAWN SHOP GUYS: Sorry. Emitting heat is the best I can do.
ALT text

CUSTOMER: I have no IO monad and I must scream. PAWN SHOP GUYS: Sorry. Emitting heat is the best I can do.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Liberator: A drag-and-drop visual programming environment for Haskell. ~ Miles Berry. github.com/milesberry/liberator

github.com

GitHub - milesberry/liberator: A drag-and-drop visual programming environment for Haskell, designed for teaching AQA A-Level Computer Science. Build programs by connecting nodes on a canvas instead of writing text — then evaluate them live to see results.

A drag-and-drop visual programming environment for Haskell, designed for teaching AQA A-Level Computer Science. Build programs by connecting nodes on a canvas instead of writing text — then evaluat...

Robin Palotai
@robinp@mastodon.social

Guys, I realized I was doing development stone-age style.

You _need_ to try this, these new tools are absolute game-changers, unlocking 2x to 10x productivity.

I know this is not a popular opinion, but look, we need to keep pace with the changes of times. It might feel hard at first, or at least feel alien, but, we need to part from our old, sluggish, slow ways.

So, enable the DuplicateRecordFields and OverloadedRecordDot extensions, now!

Jaro Reinders
@jaror@social.edu.nl

Packages like `text` reach into the unstable bowels of to avoid allocating intermediate structures when reading IO.

But it is possible to do fusible lazy IO:

```
produce :: IO [Char]
produce = IO $ \s0 ->
(# s0 , build $ \c n ->
let go s = case runIO getChar s of
(# s' , x #) -> c x (go s')
in go s0
#)
```

Perhaps GHC could expose something like that and the text package could use it.

Jaro Reinders
@jaror@social.edu.nl

Packages like `text` reach into the unstable bowels of to avoid allocating intermediate structures when reading IO.

But it is possible to do fusible lazy IO:

```
produce :: IO [Char]
produce = IO $ \s0 ->
(# s0 , build $ \c n ->
let go s = case runIO getChar s of
(# s' , x #) -> c x (go s')
in go s0
#)
```

Perhaps GHC could expose something like that and the text package could use it.

Poseidon Framework
@poseidon@ecoevo.social

New qjanno release v1.0.1.0! Please see the changelog here: github.com/poseidon-framework/

Release Release v1.0.1.0 · poseidon-framework/qjanno

This is a maintenance release to bring qjanno in sync with Poseidon v3.0.0. It comes with a new column order template for .janno files, featuring the new columns introduced with the v3.0.0 schema r...

HaskellOrg
@haskell@fosstodon.org

A blog post by Brandon "jberryman" Simmons “Linking Smaller Haskell Binaries” (2023) brandon.si/code/linking-smalle

brandon.si

Linking Smaller Haskell Binaries | Brandon Simmons' website

Haskell binaries can get quite large (think ~100MB), especially for projects with many transitive dependencies. Here are two strategies that can help at link time, the latter being more experimental. I used the test-pandoc binary from pandoc on GHC 9.2.5 below. This was nice because obviously it was easy to test if linking broke anything (just run the tests). -split-sections and --gc-sections You can instruct ghc to emit code in individual minimal sections, allowing the linker to easily find and remove dead code. This looks like, in your cabal.project:

HaskellOrg
@haskell@fosstodon.org

Today is a great day for some major news!
DataFrame v1.0.0.0 has been officially released! Step up your exploratory data analysis in with Typed data frames, direct connection to HuggingFace data sets, and Python integration through Apache Arrow.

discourse.haskell.org/t/ann-da

discourse.haskell.org

[ANN] dataframe 1.0.0.0

It’s been roughly two years of work on this and I think things are in a good enough state that it’s worth calling this v1. Features Typed dataframes We got there eventually and I think we got there in a way that still looks nice. There is now a DataFrame.Typed API that tracks the entire schema of the dataframe - column names, misapplied operations etc are now compile time failures and you can easily move between exploratory and pipeline work. This is in large part thanks to maxigit and mcoady (...

Björn Gohla
@6d03@mathstodon.xyz

Wot?

```
• Couldn't match expected type ‘bytestring-0.11.5.3:Data.ByteString.Internal.Type.ByteString’
with actual type ‘bytestring-0.11.5.3:Data.ByteString.Lazy.Internal.ByteString’
```

Abhinav 🧭
@abnv@fantastic.earth

I ported @mattmight’s conversion code (matt.might.net/articles/cps-co) to and after some fighting with the type system, it worked! To make the work with the Cont monad, I had to remove recursive lets and hence, functions being able to call themselves recursively, but the rest works fine.

The attached images show the conversion of the Fibonacci function into the CPS version.

Fibonacci function in Lisp: (let ([fib (λ (n) (let ([fib' (λ (n f) (if (= n 0) 0 (if (= n 1) 1 (+ (f (- n 1) f) (f (- n 2) f)))))]) (fib' n fib')))]) (fib 10))
ALT text

Fibonacci function in Lisp: (let ([fib (λ (n) (let ([fib' (λ (n f) (if (= n 0) 0 (if (= n 1) 1 (+ (f (- n 1) f) (f (- n 2) f)))))]) (fib' n fib')))]) (fib 10))

Fibonacci function in Lisp: (let ([fib (λ (n) (let ([fib' (λ (n f) (if (= n 0) 0 (if (= n 1) 1 (+ (f (- n 1) f) (f (- n 2) f)))))]) (fib' n fib')))]) (fib 10))
ALT text

Fibonacci function in Lisp: (let ([fib (λ (n) (let ([fib' (λ (n f) (if (= n 0) 0 (if (= n 1) 1 (+ (f (- n 1) f) (f (- n 2) f)))))]) (fib' n fib')))]) (fib 10))

CPS version of Fibonacci function in Lisp: (let ([fib (λ (n k0) (let ([fib' (λ (n f k1) ((λ (k2) ((λ (v3) (if v3 (k2 0) ((λ (k4) ((λ (v5) (if v5 (k4 1) ((λ (v9) (f v9 f (λ (v6) ((λ (v8) (f v8 f (λ (v7) (k4 (+ v6 v7))))) (- n 2))))) (- n 1)))) (= n 1))) k2))) (= n 0))) k1))]) (fib' n fib' k0)))]) (fib 10 return))
ALT text

CPS version of Fibonacci function in Lisp: (let ([fib (λ (n k0) (let ([fib' (λ (n f k1) ((λ (k2) ((λ (v3) (if v3 (k2 0) ((λ (k4) ((λ (v5) (if v5 (k4 1) ((λ (v9) (f v9 f (λ (v6) ((λ (v8) (f v8 f (λ (v7) (k4 (+ v6 v7))))) (- n 2))))) (- n 1)))) (= n 1))) k2))) (= n 0))) k1))]) (fib' n fib' k0)))]) (fib 10 return))

CPS version of Fibonacci function in Lisp: (let ([fib (λ (n k0) (let ([fib' (λ (n f k1) ((λ (k2) ((λ (v3) (if v3 (k2 0) ((λ (k4) ((λ (v5) (if v5 (k4 1) ((λ (v9) (f v9 f (λ (v6) ((λ (v8) (f v8 f (λ (v7) (k4 (+ v6 v7))))) (- n 2))))) (- n 1)))) (= n 1))) k2))) (= n 0))) k1))]) (fib' n fib' k0)))]) (fib 10 return))
ALT text

CPS version of Fibonacci function in Lisp: (let ([fib (λ (n k0) (let ([fib' (λ (n f k1) ((λ (k2) ((λ (v3) (if v3 (k2 0) ((λ (k4) ((λ (v5) (if v5 (k4 1) ((λ (v9) (f v9 f (λ (v6) ((λ (v8) (f v8 f (λ (v7) (k4 (+ v6 v7))))) (- n 2))))) (- n 1)))) (= n 1))) k2))) (= n 0))) k1))]) (fib' n fib' k0)))]) (fib 10 return))

Fraser Tweedale
@hackuador@functional.cafe

Thanks to Sirius-beta Labs who are once again sponsoring lunch for Hack Day. UQ St Lucia, Saturday 28 March. Be there or be a lambda cube!

luma.com/uu28az9h

luma.com

BFPG Hack Day - March 2026 · Luma

Come to BFPG Hack Day for some wholesome fun hacking on side projects, tackling tutorials, grinding axes and shaving yaks! Work together or independently.…

Abhinav 🧭
@abnv@fantastic.earth

I'm starting a series of blog posts, in which I write a and a for arithmetic in . We explore the following topics in the series:

- Parsing arithmetic expressions to ASTs.
- Compiling ASTs to bytecode.
- Interpreting ASTs.
- Efficiently executing bytecode in a VM.
- Disassembling bytecode and decompiling opcodes for debugging and testing.
- Unit testing and property-based testing for our compiler and VM.
- Benchmarking our code to see how the different passes perform.
- All the while keeping an eye on performance.

The first post of the series that focuses on writing the is now out: abhinavsarkar.net/posts/arithm

abhinavsarkar.net

A Fast Bytecode VM for Arithmetic: The Parser

We write a fast bytecode VM for arithmetic in Haskell.

Abhinav 🧭
@abnv@fantastic.earth

I've created a PR in , a simple setup framework, to add support for easy building of statically-linked executables (github.com/pwm/nixkell/pull/50). I'd appreciate it if any Nixkell users gives it a try for their projects. I've been using this code for a couple of my projects, and it works fine for me, but I'd like to have more working examples.

github.com

Add support for building statically-linked executable by abhin4v · Pull Request #50 · pwm/nixkell

This PR adds support for easily building statically-linked executable using Nixkell and Nix. Majorly, it: adds an overlays-static.nix file that configures GHC and Haskell packages for building sta...

Abhinav 🧭
@abnv@fantastic.earth

After seven years of meticulously formatting and aligning all the source code of my static site generator by hand, I finally moved to an auto-formatter today (Ormolu).

Screenshot of the summary of a git commit that says: Reformats Haskell code 66 changed files with 3201 additions and 2845 deletions
ALT text

Screenshot of the summary of a git commit that says: Reformats Haskell code 66 changed files with 3201 additions and 2845 deletions

HaskellOrg
@haskell@fosstodon.org

:haskell: GHC 9.12.4-rc1 is available for testing! Please try it out on your projects and give feedback! It is available today on the GHCup pre-release channel. See the installation instructions: discourse.haskell.org/t/ghc-9-

discourse.haskell.org

GHC 9.12.4-rc1 is now available

The GHC developers are very pleased to announce the availability of the release candidate for GHC 9.12.4. Binary distributions, source distributions, and documentation are available at downloads.haskell.org and via 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 re...

Abhinav 🧭
@abnv@fantastic.earth

Every year I try to solve some problems from the competition in a not straightforward way. This year I solved the day 19 problem “Aplenty” by compiling the problem input to an executable file.

A new post: abhinavsarkar.net/posts/compil

abhinavsarkar.net

Solving Advent of Code

We solve Advent of Code '23 'Aplenty' by compiling the problem input.

Robin Palotai
@robinp@mastodon.social

Guys, I realized I was doing development stone-age style.

You _need_ to try this, these new tools are absolute game-changers, unlocking 2x to 10x productivity.

I know this is not a popular opinion, but look, we need to keep pace with the changes of times. It might feel hard at first, or at least feel alien, but, we need to part from our old, sluggish, slow ways.

So, enable the DuplicateRecordFields and OverloadedRecordDot extensions, now!

Abhinav 🧭
@abnv@fantastic.earth

Upgraded my website generator to use 9.4 and it took two hours to build. Well, that's the cost I pay for using bleeding edge software.

Robin Palotai
@robinp@mastodon.social

Guys, I realized I was doing development stone-age style.

You _need_ to try this, these new tools are absolute game-changers, unlocking 2x to 10x productivity.

I know this is not a popular opinion, but look, we need to keep pace with the changes of times. It might feel hard at first, or at least feel alien, but, we need to part from our old, sluggish, slow ways.

So, enable the DuplicateRecordFields and OverloadedRecordDot extensions, now!

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared March 09, 2026. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared March 9, 2026

The readings shared in Bluesky on 9 March 2026 are: Fantastic simprocs and how to write them. ~ Yaël Dillies, Paul Lezeau. #LeanProver #ITP Formalization in Lean of faithfully flat descent of project

Abhinav 🧭
@abnv@fantastic.earth

Writing an for is almost a rite of passage for any programming language implementer, and it’s my turn now. In this post, I write not one but four Brainfuck in : abhinavsarkar.net/posts/brainf

Please boost for reach. If you have any questions or comments, please reply to this post.

abhinavsarkar.net

Interpreting Brainfuck in Haskell

We write a few Brainfuck interpreters in Haskell.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Category theory for programming. ~ Benedikt Ahrens, Kobe Wullaert. arxiv.org/abs/2209.01259v1

arxiv.org

Category Theory for Programming

In these lecture notes, we give a brief introduction to some elements of category theory. The choice of topics is guided by applications to functional programming. Firstly, we study initial algebras, which provide a mathematical characterization of datatypes and recursive functions on them. Secondly, we study monads, which give a mathematical framework for effects in functional languages. The notes include many problems and solutions.

Abhinav 🧭
@abnv@fantastic.earth

After a gap of 1.5 years since the last part, I have finally finished writing the third part of my post series on implementing Co. Planning to publish it this weekend.

Implementing Co, a Small Interpreted Language With Coroutines #3: Adding Coroutines
ALT text

Implementing Co, a Small Interpreted Language With Coroutines #3: Adding Coroutines

Ramin Honary
@ramin_hal9001@fe.disroot.org · Reply to Hippo 🍉

@badrihippo modern frameworks like React, Vue, and Van.js are all very similar, but I have not seen a consistent name for this family of frameworks. I have heard it called “The Elm Architecture,” because they are loosely based on how the Elm programming language originally did GUI programming in the browser. I have also heard it called the Model-View-Update paradigm. But most people just call it “React-like” or “Reactive Programming” because they are all similar to the very popular “React.js” framework.

Note that this should not be confused with Functional Reactive Programming (FRP), although the two are not completely different. As I understand it, React-like GUIs and FRP can both be implemented on top of a more powerful and more general computation model called “propagators” (here is the PDF of the original Propagators paper).

@dthompson wrote a really good blog post about FRP, propagators, and React-like frameworks.

I hope that helps, but I am not as well-versed in the theory of this stuff as I should be.

Oh, and I should say, before React-like took over the world wide web, GUI programming was mostly intertwined with Object Oriented Programming and design, so a good place to start might be to read up on Smalltalk OOP and GUI design.

#tech #software #GUI #ReactiveProgramming #FRP #Scheme #Haskell #SchemeLang #Propagators #ElmArchitecture #ReactJS #Smalltalk #OOP #ObjectOriented

fe.disroot.org

FEDIsroot

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared March 04, 2026. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared March 4, 2026

The readings shared in Bluesky on 4 March 2026 are: When AI writes the world’s software, who verifies it? ~ Leonardo de Moura. #AI #LeanProver #ITP Formalising sphere packing in Lean. ~ Chris Birkbec

HaskellOrg
@haskell@fosstodon.org

Layoutz! Zero-dep Elm-style TUI’s for - now w/ terminal plots & more

discourse.haskell.org/t/layout

discourse.haskell.org

Layoutz 0.3.2 🪶 Zero-dep Elm-style TUI’s for Haskell - now w/ terminal plots & more

Hello! Layoutz has quite some improvements including built-in granite-esque plots. Thanks for your great feedback thus far … sure you will find some more rough edges.

Andres Löh
@kosmikus@functional.cafe

Please consider applying for the Foundation Board of Directors: discourse.haskell.org/t/call-f

Deadline is one week from now.

discourse.haskell.org

Call for applications to the Haskell Foundation board of directors

The Haskell Foundation’s directors are pleased to announce the nomination process for seats on the Foundation’s board of directors. The Haskell Foundation is a non-profit organization whose mission is to support industrial users of Haskell. The board is the ultimate decision-making body of the Foundation and provides its strategic leadership. It ensures that the Foundation is working toward achieving its mission, and it appoints and supervises senior members of the Foundation’s staff. Followi...

HaskellOrg
@haskell@fosstodon.org

It's there folks! The results of the State of 2025 survey have been published

discourse.haskell.org/t/state-

discourse.haskell.org

State of Haskell 2025 results

At the end of 2025, the Haskell Foundation re-started the Haskell Yearly Survey. I’d like to thank Taylor Fausak for being supportive of our effort in conducting these surveys. The last survey was conducted in 2022 and the post discussing those results is here: https://taylor.fausak.me/2022/11/18/haskell-survey-results/ The full results are available here: State of Haskell 2025 Raw Results - Google Drive. If you’d like a CSV to play around with, that has been made available as well: 2025 Surv...

Malvin
@m4lvin@goto.fiets.pizza

I always enjoy giving this lecture 😃 #haskell

Blackboard with a diagram about "Functor" in Haskell. The example functions used are "length :: String -> Int" and "odd :: Int -> Bool". The diagram also shows the two functor laws as "fmap id = id" and "fmap odd . fmap length = fmap (odd.length)".
ALT text

Blackboard with a diagram about "Functor" in Haskell. The example functions used are "length :: String -> Int" and "odd :: Int -> Bool". The diagram also shows the two functor laws as "fmap id = id" and "fmap odd . fmap length = fmap (odd.length)".

Abhinav 🧭
@abnv@fantastic.earth

It is a good day to unleash the agent of chaos.

Screenshot of the documentation of the Haskell function accursedUnutterablePerformIO: accursedUnutterablePerformIO :: IO a -> a This "function" has a superficial similarity to unsafePerformIO but it is in fact a malevolent agent of chaos. It unpicks the seams of reality (and the IO monad) so that the normal rules no longer apply. It lulls you into thinking it is reasonable, but when you are not looking it stabs you in the back and aliases all of your mutable buffers. The carcass of many a seasoned Haskell programmer lie strewn at its feet. Witness the trail of destruction: https://github.com/haskell/bytestring/commit/71c4b438c675aa360c79d79acc9a491e7bbc26e7 https://github.com/haskell/bytestring/commit/210c656390ae617d9ee3b8bcff5c88dd17cef8da https://github.com/haskell/aeson/commit/720b857e2e0acf2edc4f5512f2b217a89449a89d https://ghc.haskell.org/trac/ghc/ticket/3486 https://ghc.haskell.org/trac/ghc/ticket/3487 https://ghc.haskell.org/trac/ghc/ticket/7270 https://gitlab.haskell.org/ghc/ghc/-/issues/22204 Do not talk about "safe"! You do not know what is safe! Yield not to its blasphemous call! Flee traveller! Flee or you will be corrupted and devoured!
ALT text

Screenshot of the documentation of the Haskell function accursedUnutterablePerformIO: accursedUnutterablePerformIO :: IO a -> a This "function" has a superficial similarity to unsafePerformIO but it is in fact a malevolent agent of chaos. It unpicks the seams of reality (and the IO monad) so that the normal rules no longer apply. It lulls you into thinking it is reasonable, but when you are not looking it stabs you in the back and aliases all of your mutable buffers. The carcass of many a seasoned Haskell programmer lie strewn at its feet. Witness the trail of destruction: https://github.com/haskell/bytestring/commit/71c4b438c675aa360c79d79acc9a491e7bbc26e7 https://github.com/haskell/bytestring/commit/210c656390ae617d9ee3b8bcff5c88dd17cef8da https://github.com/haskell/aeson/commit/720b857e2e0acf2edc4f5512f2b217a89449a89d https://ghc.haskell.org/trac/ghc/ticket/3486 https://ghc.haskell.org/trac/ghc/ticket/3487 https://ghc.haskell.org/trac/ghc/ticket/7270 https://gitlab.haskell.org/ghc/ghc/-/issues/22204 Do not talk about "safe"! You do not know what is safe! Yield not to its blasphemous call! Flee traveller! Flee or you will be corrupted and devoured!

Abhinav 🧭
@abnv@fantastic.earth

Which is your favourite parsing library and why?

  • Parsec2 (25%)
  • ReadP0 (0%)
  • Attoparsec1 (13%)
  • Megaparsec4 (50%)
  • Alex + Happy0 (0%)
  • Flatparse1 (13%)
  • Earley0 (0%)
  • Parsley0 (0%)
  • Streamly0 (0%)
  • Polyparse0 (0%)
pandoc
@pandoc@fosstodon.org

Pandoc is written in (haskell.org), an advanced, purely functional programming language. It was chosen for its great parser support, which was ahead of its time when pandoc was born in 2006. The language is also uniquely suited for a long-lived project, as the strong typing helps tremendously to keep things maintainable.

haskell.org

Haskell Language

The Haskell purely functional programming language home page.

pandoc
@pandoc@fosstodon.org

Pandoc is written in (haskell.org), an advanced, purely functional programming language. It was chosen for its great parser support, which was ahead of its time when pandoc was born in 2006. The language is also uniquely suited for a long-lived project, as the strong typing helps tremendously to keep things maintainable.

haskell.org

Haskell Language

The Haskell purely functional programming language home page.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared February 24, 2026. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 24, 2026

The readings shared in Bluesky on 24 February 2026 are: Formalizing Gröbner basis theory in Lean. ~ Junyu Guo, Hao Shen, Junqi Liu, Lihong Zhi. #LeanProver #ITP #Math Integral curves and flows on Ban

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Haskell meets Evariste. ~ Paulo R. Pereira, Jose N. Oliveira. arxiv.org/abs/2602.16809v1

arxiv.org

Haskell meets Evariste

Since its birth as a new scientific body of knowledge in the late 1950s, computer programming has become a fundamental skill needed in many other disciplines. However, programming is not easy, it is prone to errors and code re-use is key for productivity. This calls for high-quality documentation in software libraries, which is quite often not the case. Taking a few Haskell functions available from the Hackage repository as case-studies, and comparing their descriptions with similar functions in other languages, this paper shows how clarity and good conceptual design can be achieved by following a so-called easy-hard-split formal strategy that is quite general and productive, even if used informally. This strategy is easy to use in functional programming and can be applied to both program analysis and synthesis.

HaskellOrg
@haskell@fosstodon.org

Exported for tests only: Precise control over API visibility with custom warnings

tech.scrive.com/exported-for-t

tech.scrive.com

Exported for tests only: Precise control over API visibility with custom warnings

This article describes a pattern made possible by recent advances in GHC 9.8, to allow library authors to control how internal data constructors can be labelled as unsafe for human consumption, while needing to be exported for test suites. Making invalid states unrepresentable One of the mantras of strongly-typed

HaskellOrg
@haskell@fosstodon.org

New Debugger Release: v0.12

discourse.haskell.org/t/new-ha

discourse.haskell.org

New Haskell Debugger Release: v0.12

I’m happy to announce a new release of the new modern step-through interactive debugger (haskell-debugger). You can find installation instructions in GHC Debugger. Here’s the changelog for haskell-debugger-0.12 Improved exceptions support! Break-on-exception breakpoints now provide source locations And exception callstacks based on the ExceptionAnnotation mechanism. Introduced stacktraces support! Stack frames decoded from interpreter frames with breakpoints are displayed Stack frames dec...

HaskellOrg
@haskell@fosstodon.org

Iced-hs, a wrapper for the GUI library iced-rs, has been updated to iced 0.14.

Read more details at discourse.haskell.org/t/update

discourse.haskell.org

Updated iced-hs to iced 0.14

Initially announced here, iced-hs is a Haskell wrapper for iced Rust library. It provides an Elm-like way to build desktop apps. Currently, there’s a segfault with new Rust versions. Yet, I felt there’s still a value in updating the wrapper to latest iced version. You can use it with Rust 1.89.

HaskellOrg
@haskell@fosstodon.org

[ANN] kdl-hs 1.0.0 released with v2 support

kdl-hs is a parser for the configuration language, now compliant with the v2 standard.

discourse.haskell.org/t/ann-kd

discourse.haskell.org

[ANN] kdl-hs 1.0.0 released with v2 support

kdl-hs is a parser for the KDL configuration language, providing both monadic and arrow-based decoding functionality. v1.0.0 reimplements the parser to be v2 compliant. The parser now preserves format information, so KDL.render is now implemented and outputs the same format the user provided. The parser can now also be configured to include span information, which is attached to each element in the tree. https://hackage.haskell.org/package/kdl-hs-1.0.0

Abhinav 🧭
@abnv@fantastic.earth

I've written a series of blog posts, in which I write a and a for arithmetic in . We explore the following topics in the series:

- Parsing arithmetic expressions to ASTs.
- Compiling ASTs to bytecode.
- Interpreting ASTs.
- Efficiently executing bytecode in a VM.
- Disassembling bytecode and decompiling opcodes for debugging and testing.
- Unit testing and property-based testing for our compiler and VM.
- Benchmarking our code to see how the different passes perform.
- All the while keeping an eye on performance.

The third and final post of the series that focuses on writing the virtual machine is now out: abhinavsarkar.net/posts/arithm

abhinavsarkar.net

A Fast Bytecode VM for Arithmetic: The Virtual Machine

We write a fast bytecode VM for arithmetic in Haskell.

Shoe Bill
@the@ultracrepidarian.mysteriar.ch

Why has no one written a Fediverse server in Haskell?

I would love to be wrong about this, obviously, but I've looked, and I can't find anything that speaks ActivityPub in Haskell.

Is Haskell just a bad language to use for something like this, and if so then why, or what's the reason if not that?

#Haskell #Fediverse

Lobsters
@lobsters@mastodon.social

Linking Smaller Haskell Binaries via @hongminhee lobste.rs/s/xeerdn
brandon.si/code/linking-smalle

brandon.si

Linking Smaller Haskell Binaries | Brandon Simmons' website

Haskell binaries can get quite large (think ~100MB), especially for projects with many transitive dependencies. Here are two strategies that can help at link time, the latter being more experimental. I used the test-pandoc binary from pandoc on GHC 9.2.5 below. This was nice because obviously it was easy to test if linking broke anything (just run the tests). -split-sections and --gc-sections You can instruct ghc to emit code in individual minimal sections, allowing the linker to easily find and remove dead code. This looks like, in your cabal.project:

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared February 19, 2026. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 19, 2026

The readings shared in Bluesky on 19 February 2026 are: Hennessy-Milner logic in CSLib, the Lean computer science library. ~ Fabrizio Montesi, Marco Peressotti, Alexandre Rademaker. #LeanProver #ITP

Abhinav 🧭
@abnv@fantastic.earth

So, you've heard of the new hotness that is , for creating reproducible and isolated development environments, and want to use it for your new project? But you are unclear about how to get started? Then this is the guide you are looking for: abhinavsarkar.net/posts/nix-fo

abhinavsarkar.net

Getting Started with Nix for Haskell

A guide to easily get started with Nix for Haskell projects.

jnkrtech
@jnkrtech@treehouse.systems

I have an algebraic data type for an AST, which takes a type parameter for the type of expression that the AST holds. I’m writing a function which walks the AST, transforming certain nodes, but always keeping the types of the nodes the same. For example, I can provide this function a function for transforming identifiers (like for renaming them), but the transformer has to return another identifier. The outer structure of the AST stays the same. This is important because I only want to specify transformation functions for the “interesting” cases, and allow the majority of cases to use a default transformer which does nothing more than traverse down the node’s children.

What would you name such a thing? I wouldn’t call it “map” because it doesn’t change the type parameter. It’s not “fold” because it doesn’t have the ability to vary the return type at all. It might be a special case of some other morphism, which would be helpful, but I’m not seeing it.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared February 14, 2026. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 14, 2026

The readings shared in Bluesky on 14 February 2026 are: Formalization of the Golay-Hopf machine: A unified algebraic framework for Hida, Iwasawa, and Yang-Baxter structures. ~ Yoshihiro Hasegawa. #IT

HaskellOrg
@haskell@fosstodon.org

2026 retrospective by @jmct

discourse.haskell.org/t/amerih

discourse.haskell.org

AmeriHac 2026 retrospective

This past weekend we held the first ever AmeriHac, a ZuriHac-style hackathon for the North American Haskell community. When I first proposed the idea of a North American event to the HF board, my criterion for success was simple: 100 attendees. We had 110, so by that measure we succeeded. But numbers are only part of the story, of course. The Event Jane Street hosted us at their offices in New York, it’s difficult to overstate how much we appreciate their generosity. The food was exemplary, the...

Abhinav 🧭
@abnv@fantastic.earth

In my quest of solving problems in interesting ways, this time I solved the 2020 problem "Seating System" with comonads and stencils in . Read my latest post about it: abhinavsarkar.net/posts/solvin

abhinavsarkar.net

Solving Advent of Code “Seating System” with Comonads and Stencils

We solve the Advent of Code 2020 “Seating System” challenge in Haskell using comonads and stencils.

HaskellOrg
@haskell@fosstodon.org

It's ON!

fosstodon.org

ZuriHac (@zurihac@fosstodon.org)

ZuriHac 2026 - Registrations are open! ZuriHac is the biggest Haskell community event in the world: a completely free, three-day grassroots coding festival co-organized by the Zürich Friends of Haskell and the OST Eastern Switzerland University of Applied Science. It is not your standard conference with papers and presentations, but features fantastic keynotes, hands-on tracks, hacking on many of your favourite projects, and of course lots of socializing! Register now: https://zureg.zfoh.ch/register

ZuriHac
@zurihac@fosstodon.org

ZuriHac 2026 - Registrations are open!

ZuriHac is the biggest Haskell community event in the world: a completely free, three-day grassroots coding festival co-organized by the Zürich Friends of Haskell and the OST Eastern Switzerland University of Applied Science. It is not your standard conference with papers and presentations, but features fantastic keynotes, hands-on tracks, hacking on many of your favourite projects, and of course lots of socializing!

Register now: zureg.zfoh.ch/register

zureg.zfoh.ch

Registration

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Hello, Haskell: Getting started in 2026. ~ Lukasz Tymoszczuk. lukastymo.com/posts/025-hello-

lukastymo.com

Hello, Haskell: Getting Started in 2026

Read this if you want to: see beginner examples that link Haskell’s syntax to its underlying mental models – types, pattern matching, declarative style and do see examples of Haskell’s distinctive syntax in practice learn what Robin Milner’s work changed in functional programming write and run code as you go Introduction In the current AI era, Rust and Python draw the most attention from learners and employers. Haskell, by contrast, remains niche: it trends lower on Google Trends and has far fewer job listings on LinkedIn. When roles do appear, the bar can be high enough that newcomers struggle to get started.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

"Five-Point Haskell": Total depravity (and defensive typing). ~ Justin Le. blog.jle.im/entry/five-point-h

blog.jle.im

"Five-Point Haskell": Total Depravity (and Defensive Typing)

I have thought about distilling the principles by which I program Haskell, and how I’ve been able to steer long-lived projects over years of growth, refactorings, and changes in demands. I find myself coming back to a few distinct and helpful “points” (“doctrines”, if you may allow me to say) that have yet to lead me astray. With a new age of software development coming, what does it even mean to write good, robust, correct code? It is long overdue to clarify the mindset we use to define “good” coding principles. In this series, Five-Point Haskell, I’ll set out to establish a five-point framework for typed functional programming (and Haskell-derived) design that aims to produce code that is maintainable, correct, long-lasting, extensible, and beautiful to write and work with. We’ll reference real-world case studies with actual examples when we can, and also attempt to dispel thought-leader sound bites that have become all too popular on Twitter (“heresies”, so to speak). Let’s jump right into point 1: the doctrine of Total Depravity, and why Haskell is perfectly primed to make living with it as frictionless as possible. Total Depravity: If your code’s correctness depends on keeping complicated interconnected structure in your head, a devastating incident is not a matter of if but when.Therefore, delegate these concerns to tooling and a sufficiently powerful compiler, use types to guard against errors, and free yourself to only mentally track the actual important things.

Björn Gohla
@6d03@mathstodon.xyz

An new proposal for passing implicit parameters to functions: github.com/ghc-proposals/ghc-p

Done the right way; as opposed to the existing ImplicitParams extension, which is practically useless.

github.com

Nominal implicit parameters by lortabac · Pull Request #741 · ghc-proposals/ghc-proposals

This proposal introduces NominalImplicitParams, a new GHC extension that provides first-class support for dynamic scoping with robust and predictable semantics. Rendered

Björn Gohla
@6d03@mathstodon.xyz

An new proposal for passing implicit parameters to functions: github.com/ghc-proposals/ghc-p

Done the right way; as opposed to the existing ImplicitParams extension, which is practically useless.

github.com

Nominal implicit parameters by lortabac · Pull Request #741 · ghc-proposals/ghc-proposals

This proposal introduces NominalImplicitParams, a new GHC extension that provides first-class support for dynamic scoping with robust and predictable semantics. Rendered

HaskellOrg
@haskell@fosstodon.org

Case Study: Automating Type Safety for Mission-Critical Industrial Systems, by Stack Builders

stackbuilders.com/case-studies

stackbuilders.com

Plow Technologies Case Study

Plow Technologies, a U.S. leader in oil and gas well site automation with over a decade of field experience, delivers custom control systems that make even complex industrial challenges manageable. Now part of PakEnergy, Plow continues driving innovation across critical industries.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared January 19, 2026. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared January 19, 2026

The readings shared in Bluesky on 19 January 2026 are: Broken proofs and broken provers. ~ Lawrence Paulson. #ITP #IsabelleHOL #RocqProver #LeanProver A formalization of Borel determinacy in Lean. ~

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Logic programming with extensible types. ~ Ivan Perez, Angel Herranz. arxiv.org/abs/2601.03836v1

arxiv.org

Logic Programming with Extensible Types

Logic programming languages present clear advantages in terms of declarativeness and conciseness. However, the ideas of logic programming have been met with resistance in other programming communities, and have not generally been adopted by other paradigms and languages. This paper proposes a novel way to incorporate logic programming in an existing codebase in a typed functional programming language. Our approach integrates with the host language without sacrificing static typing, and leverages strengths of typed functional programming such as polymorphism and higher-order. We do so by combining three ideas. First, we use the extensible types technique to allow values of the host language to contain logic variables. Second, we implement a unification algorithm that works for any data structure that supports certain operations.Third, we introduce a domain-specific language to define and query predicates. We demonstrate our proposal via a series of examples, and provide aids to make the notation convenient for users, showing that the proposed approach is not just technically possible but also practical. Our ideas have been implemented in the language Haskell with very good results.

Jens Ohlig
@johl@mastodon.xyz

This is so niche and yet so relevant to my interests: "Kip is an experimental programming language that combines Turkish grammar rules with a type system. Case endings, vowel harmony, and other Turkish morphological features are an integral part of Kip's type-checking process."

github.com/kip-dili/kip/wiki/T

github.com

Tutorial

A programming language in Turkish where grammatical case and mood are part of the type system. - kip-dili/kip

Jens Ohlig
@johl@mastodon.xyz

This is so niche and yet so relevant to my interests: "Kip is an experimental programming language that combines Turkish grammar rules with a type system. Case endings, vowel harmony, and other Turkish morphological features are an integral part of Kip's type-checking process."

github.com/kip-dili/kip/wiki/T

github.com

Tutorial

A programming language in Turkish where grammatical case and mood are part of the type system. - kip-dili/kip

HaskellOrg
@haskell@fosstodon.org

Aztecs v0.15: A functional, archetypal ECS for game engines

discourse.haskell.org/t/aztecs

discourse.haskell.org

Aztecs v0.15: A functional, archetypal ECS for Haskell game engines

I’m really excited to announce the latest version of Aztecs, an ECS for Haskell. An ECS is a modern approach to organizing your application state as a database. import Aztecs.ECS import qualified Aztecs.ECS.Access as A import qualified Aztecs.ECS.Query as Q import qualified Aztecs.ECS.System as S import Control.Monad.IO.Class import Data.Function ((&)) newtype Position = Position Int deriving (Show) instance Component Position newtype Velocity = Velocity Int deriving (Show) instance Compone...

Abhinav 🧭
@abnv@fantastic.earth

I wrote the fifth part of my series “Implementing Co, a small programming language with ”. This time, we add support for sleep in for time-based executions. abhinavsarkar.net/posts/implem

abhinavsarkar.net

Implementing Co, a Small Language With Coroutines #5: Adding Sleep

We implement Co, a small language with coroutines and channels.

HaskellOrg
@haskell@fosstodon.org

Hyperbole 0.6, the web framework for interactive applications with minimal JS, has been released! See it in action on hyperbole.live

Announcement: discourse.haskell.org/t/ann-hy

discourse.haskell.org

[ANN] Hyperbole 0.6 - ViewState, server push, concurrency controls, fancy docs

Hello fellow Javascript-avoidant Haskellers! Hyperbole has a new release! The examples site https://hyperbole.live is now the official documentation. It’s been painstakingly updated to include longer-form docs, including code snippets and live examples with source code links. I think it’s pretty. Fun new stuff: Server actions can use pushUpdate to update arbitrary HyperViews, enabling all sorts of shenanigans with long-running actions Control overlapping updates with Concurrency = Replac...

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared January 14, 2026. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared January 14, 2026

The readings shared in Bluesky on 14 January 2026 are: A lambda-superposition tactic for Isabelle/HOL. ~ Massin Guerdi. #ITP #IsabelleHOL Adding sorts to an Isabelle formalization of superposition. ~

HaskellOrg
@haskell@fosstodon.org

"DataFrame January 2026 Updates"

discourse.haskell.org/t/datafr

discourse.haskell.org

DataFrame January 2026 Updates

DataFrame update dump (0.3.1.1 → 0.4.0.5): faster, safer, and a lot more expressive I’ve been heads-down shipping a pile of improvements to DataFrame over the last few releases, and I wanted to share a “why you should care” summary (with some highlights + a couple examples). Highlights Ecosystem You can now read SQL tables using the dataframe-persistent (written by @junjihashimoto) Convert DataFrames into hasktorch tensors and back with dataframe-hasktorch. Symbolic regression (based...

HaskellOrg
@haskell@fosstodon.org

"The Hazy Haskell Compiler" on Discourse

discourse.haskell.org/t/the-ha

discourse.haskell.org

The Hazy Haskell Compiler

I’m proud to showcase Hazy, my Haskell compiler. This is a project I have been working on in private for 3 years. It’s unfortunately not finished but it’s at the point where it’s fairly interesting. The type checker largely works and it’s able to generate Javascript. Though I haven’t tested the generated code yet. My main goal with this is to explore how I can make Haskell more performant. I plan to implement lifetimes, linear types, levity polymorphism etc, like I did with my toy language Aith....

DiazCarrete
@DiazCarrete@hachyderm.io

Got so furious while trying to get this HasField instance to compile that I bashed my face against the keyboard, inserting letters like k s t u v m a b wholly at random. Lo and behold, now it typechecks:

Code that defines a "HasField" instance for the Optic type from the "optics-core" library. The idea is to be able use OverloadedRecordDot to compose optics, with the "the" identity optic as the start of the composition. {-# LANGUAGE UndecidableInstances #-} module Optics.Lens.Dot where import GHC.Records import GHC.TypeLits import Optics.Core instance (GField (name :: Symbol) u v a b, JoinKinds k A_Lens m, AppendIndices is NoIx ks) => HasField name (Optic k is s t u v) (Optic m ks s t a b) where getField = (% gfield @name) the :: Iso a b a b the = equality
ALT text

Code that defines a "HasField" instance for the Optic type from the "optics-core" library. The idea is to be able use OverloadedRecordDot to compose optics, with the "the" identity optic as the start of the composition. {-# LANGUAGE UndecidableInstances #-} module Optics.Lens.Dot where import GHC.Records import GHC.TypeLits import Optics.Core instance (GField (name :: Symbol) u v a b, JoinKinds k A_Lens m, AppendIndices is NoIx ks) => HasField name (Optic k is s t u v) (Optic m ks s t a b) where getField = (% gfield @name) the :: Iso a b a b the = equality

amen zwa, esq.
@AmenZwa@mathstodon.xyz

"Write Yourself a Scheme in 48 Hours: An Introduction to Haskell through Example", Tang (2007)

upload.wikimedia.org/wikipedia

I'm well and truly miffed—until this moment, I'd never come across this little jewel of a free ebook.🤦‍♂️

This book teaches practical (like monadic parsing) through an implementation of a large subset of R5RS interpreter, all in just 138 pp. An experienced FP , even one who is unfamiliar with Haskell and Scheme (although I’ve not met such a person), can plough through this text, in one sitting.

It's brilliant!

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

: Conjuntos de puntos enteros en regiones rectangulares. jaalonso.github.io/exercitium/

jaalonso.github.io

Conjuntos de puntos enteros en regiones rectangulares

Los puntos de una cuadrícula se puede representar mediante pares de números enteros type Punto = (Int,Int) y las regiones rectangulares mediante el siguiente tipo de dato data Region = Rectangulo Pu

amen zwa, esq.
@AmenZwa@mathstodon.xyz

"Write Yourself a Scheme in 48 Hours: An Introduction to Haskell through Example", Tang (2007)

upload.wikimedia.org/wikipedia

I'm well and truly miffed—until this moment, I'd never come across this little jewel of a free ebook.🤦‍♂️

This book teaches practical (like monadic parsing) through an implementation of a large subset of R5RS interpreter, all in just 138 pp. An experienced FP , even one who is unfamiliar with Haskell and Scheme (although I’ve not met such a person), can plough through this text, in one sitting.

It's brilliant!

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared December 29, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared December 29, 2025

The readings shared in Bluesky on 29 December 2025 are: Hint-based SMT proof reconstruction. ~ Joshua Clune, Haniel Barbosa, Jeremy Avigad. #ITP #LeanProver #SMT The biggest controversy in maths coul

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Advent of Code 2025: Haskell solution reflections for all 12 days. ~ Justin Le. blog.jle.im/entry/advent-of-co

blog.jle.im

Advent of Code 2025: Haskell Solution Reflections for all 12 Days

Merry Christmas all! This is my annual Advent of Code post! Advent of Code is a series of (this year) 12 daily Christmas-themed programming puzzles that are meant to be fun diversions from your daily life, help you find a bit of whimsy in your world, give you a chance to explore new ideas and program together with your friends. I always enjoy discussing creative ways to solve these puzzles every day, and it’s become a bit of an annual highlight for me and a lot of others. My favorite part about these puzzles is that they are open ended enough that there are usually many different interesting ways to solve them — it’s not like a stressful interview question where you have to recite the obscure incantation to pass the test. In the past I’ve leveraged group theory, galilean transformations and linear algebra, and more group theory. Haskell is especially fun for these because if you set up your abstractions in just the right way, the puzzles seem to solve themselves. It’s a good opportunity every year to get exposed to different parts of the Haskell ecosystem! Last year, I moved almost all of my Haskell code to an Advent of Code Megarepo, and I also write up my favorite ways to solve each one in the megarepo wiki. All of this year’s 12 puzzles are here, but I’ve also included links to each individual one in this post. I’m also considering expanding some of these into full on blog posts, so be on the look out, or let me know if there are any that you might want fully expanded! And if you haven’t, why not try these out yourself? Be sure to drop by the libera-chat ##advent-of-code channel to discuss any fun ways you solve them, or any questions! Thanks again to Eric for a great new fresh take on the event this year! * Day 1 - Secret Entrance — The classic Day 1 scanl * Day 2 - Gift Shop — The super efficient IntSet * Day 3 - Lobby — StateT + [] = backtracking search monad * Day 4 - Printing Department — 2D cellular automata * Day 5 - Cafeteria — The power of the data-interval library * Day 6 - Trash Compactor — Data.List manipulations * Day 7 - Laboratories — Tying the knot * Day 8 - Playground — Iterative Clustering * Day 9 - Movie Theater — IntervalSet and IntervalMap * Day 10 - Factory — Guassian Elimation, Type-safe Mutable Vectors * Day 11 - Reactor — More Knot Tying and DP! * Day 12 - Christmas Tree Farm — Counting

Kaleissin
@kaleissin@wandering.shop

Running a program (or trying to) is very late 90's nostalgic, very

configure && make && make install

.. then wait for 16 hours and realize it failed after 14 of them. The error messages was easier to understand in the 90's though, and autoconf fixed a lot of shite.

HaskellOrg
@haskell@fosstodon.org

MicroHs v0.15.0.0 released! 🎉

discourse.haskell.org/t/microh

discourse.haskell.org

MicroHs v0.15.0.0

There is a new version of MicroHs on GitHub. There are lots of little changes, and more packages on Hackage now compile. Release notes: Features New language extensions EmptyDataDeriving NondecreasingIndentation MonoLocalBinds removed MonomorphismRestriction Evaluation stats in interactive system: set +s STM (implementation from David Sabel) GHC compatible exception handling (mask etc.) System.Mem.Weak Foreign.StablePtr out.comb can be generated compressed and base64 encoded Improved Data...

Björn Gohla
@6d03@mathstodon.xyz

I have a working prototype of an to compiler. It can't do a lot yet; but it does translate enum types.

(Built on top of a lot of great existing work.)

```
ghci> Prelude.putStr =<< Prelude.readFile "./asn1-modules/bar.asn1"
BarFramework { 1 }

DEFINITIONS ::=
BEGIN

Bar ::= ENUMERATED {red, blue, yellow}

END -- BarFramework
ghci> _ = () ; $(spliceFromModuleOrDie "./asn1-modules/bar.asn1")
ghci> :i Bar
type Bar :: *
data Bar = Red | Blue | Yellow
-- Defined at <interactive>:137:11
ghci>
```

Andres Löh
@kosmikus@functional.cafe

Join us for a new episode of the , today, 2025-12-10 at 1930 UTC. This time we're discussing bidirectional parsing and printing, using as an example the autodocodec package.

youtube.com/watch?v=z9V59Y0VDc

youtube.com

Bidirectional parsing and printing (of JSON) (Haskell Unfolder #52)

Parsers and printers go hand in hand. When we want to parse unstructured data into a more structured syntax tree, we often also want to render syntax trees b...

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared December 9, 2025. jaalonso.github.io/vestigium/p -Light

jaalonso.github.io

Readings shared December 9, 2025

The readings shared in Bluesky on 9 December 2025 are: The equational theories project: Advancing collaborative mathematical research at scale. ~ Terence Tao et als. #ITP #LeanProver #Math Formalized

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared December 7, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared December 7, 2025

The readings shared in Bluesky on 7 December 2025 are: 50 years of proof assistants. ~ Lawrence Paulson. #ITP #IsabelleHOL #CoqProver #HOL DeepWiki leanprover-community/mathlib4: A comprehensive data

HaskellOrg
@haskell@fosstodon.org

Saint-Exupéry wrote “Perfection is achieved, not when there is nothing more to add, but when there is nothing left to take away.”

What would you like to see removed from to help it achieve perfection?

HaskellOrg
@haskell@fosstodon.org

Saint-Exupéry wrote “Perfection is achieved, not when there is nothing more to add, but when there is nothing left to take away.”

What would you like to see removed from to help it achieve perfection?

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared December 5, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared December 5, 2025

The readings shared in Bluesky on 5 December 2025 are: Formalization of Erdős problems. ~ Boris Alexeev. #ITP #LeanProver #Math #Autoformalization A Rocq formalization of monomial and graded orders.

HaskellOrg
@haskell@fosstodon.org

Layoutz – A tiny zero-dep lib for beautiful -style TUI's in 🪶
flora.pm/packages/@hackage/lay

reddit.com/r/haskell/comments/

discourse.haskell.org/t/layout

discourse.haskell.org

Layoutz 0.2.0 : A tiny zero-dep lib for beautiful Elm-style TUI's in Haskell 🪶

Layoutz lets you snap together compositional String elements: and now comes w/ a runtime to animate these layouts (much like a flipbook), handle keyboard inputs, fire off side effects (basically what you’d expect from en Elm-style runtime) Lmk how it feels, if there are rough edges or missing primitives. Many thanks!

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Haskell is a great language for data science. ~ Jonathan Carroll. jcarroll.com.au/2025/12/05/has

jcarroll.com.au

Haskell IS a Great Language for Data Science

I’ve been learning Haskell for a few years now and I am really liking a lot of the features, not least the strong typing and functional approach. I thought it was lacking some of the things I missed from R until I found the dataHaskell project. In this post I’ll demonstrate some of the features and explain why I think it makes for a good (great?) data science language.

Jonathan Carroll
@jonocarroll@fosstodon.org

Perhaps you saw the post series "Python is not a great language for data science"... well, here's

Haskell IS a Great Language for Data Science

jcarroll.com.au/2025/12/05/has

:haskell:
:rstats:

jcarroll.com.au

Haskell IS a Great Language for Data Science

I’ve been learning Haskell for a few years now and I am really liking a lot of the features, not least the strong typing and functional approach. I thought it was lacking some of the things I missed from R until I found the dataHaskell project. In this post I’ll demonstrate some of the features and explain why I think it makes for a good (great?) data science language.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared November 26, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared November 26, 2025

The readings shared in Bluesky on 26 November 2025 are: Verifying numerical methods with Isabelle/HOL. ~ Dustin Bryant, Jonathan Julian Huerta y Munive, Simon Foster. #ITP #IsabelleHOL #Math Introduc

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared November 25, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared November 25, 2025

The readings shared in Bluesky on 25 November 2025 are: Formalizing computational paths and fundamental groups in Lean. ~ Arthur F. Ramos, Anjolina G. de Oliveira, Ruy J. G. B. de Queiroz, Tiago M. L

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

On small functions (and Haskell). ~ Alexander Przemysław Kamiński. xlii.space/eng/small-functions/

xlii.space

On Small Functions (and Haskell)

If you’re one of my 3 stalkers (HEY Y’ALL!), you might’ve noticed that I started to write about Haskell recently. If not, well you know now :) Haskell is a nice language in a way that it teaches one (i.e. me) a new tricks. Tricks from Haskell that I started started wrtiting a piece about. I’m at the trick of small functions but I also recently read an interesting article with which I don’t (in general) agree and decided to follow on –1 Small functions considered harmful.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared November 19, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared November 19, 2025

The readings shared in Bluesky on 19 November 2025 are: An introduction to formal real analysis (Lecture 20: Limits and continuity of functions). ~ Alex Kontorovich. #ITP #LeanProver #Math Structurin

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared November 18, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared November 18, 2025

The readings shared in Bluesky on 18 November 2025 are: Teaching real analysis as a game. ~ Alex Kontorovich. #ITP #LeanProver #Math Are automated proof assistants ready for semigroup research? Orien

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared November 17, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared November 17, 2025

The readings shared in Bluesky on 17 November 2025 are: An introduction to formal real analysis (Lecture 19: The rearrangement theorems). ~ Alex Kontorovich. #ITP #LeanProver #Math Formalizing neural

pandoc
@pandoc@fosstodon.org

Pandoc allows to access and modify the Haskell runtime system (RTS) that the program runs on.

E.g., to print memory usage:

pandoc +RTS -s -RTS …

Or to limit the maximum heap size available to pandoc to 2 GB:

pandoc +RTS -M2G -RTS …

See all available options by running:

pandoc +RTS -?

This can be helpful when facing performance issues.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared November 16, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared November 16, 2025

The readings shared in Bluesky on 16 November 2025 are: To have machines make math proofs, turn them into a puzzle. ~ John Pavlus. #AI #Math #ATP #SatSolvers SITA: A framework for structure-to-instan

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared November 14, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared November 14, 2025

The readings shared in Bluesky on 14 November 2025 are: An introduction to formal real analysis (Lecture 18: Rearrangements). ~ Alex Kontorovich. #ITP #LeanProver #Math Choice trees: Representing and

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Experiences of early assessment to teach functional programming. ~ Peter Chapman. cambridge.org/core/journals/jo

cambridge.org

Experiences of early assessment to teach functional programming | Journal of Functional Programming | Cambridge Core

Experiences of early assessment to teach functional programming - Volume 35

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

How much is in a square? Calculating functional programs with squares. ~ Jose Nuno Oliveira. cambridge.org/core/journals/jo

cambridge.org

How much is in a square? Calculating functional programs with squares | Journal of Functional Programming | Cambridge Core

How much is in a square? Calculating functional programs with squares - Volume 35

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Automatically testing console I/O behavior of student submissions in Haskell. ~ Oliver Westphal, Janis Voigtländer. cambridge.org/core/journals/jo

cambridge.org

Automatically testing console I/O behavior of student submissions in Haskell | Journal of Functional Programming | Cambridge Core

Automatically testing console I/O behavior of student submissions in Haskell - Volume 35

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Checking equivalence in a non-strict language. ~ John Charles Kolesar, Ruzica Piskac, William Triest Hallahan. cambridge.org/core/journals/jo

cambridge.org

Checking equivalence in a non-strict language | Journal of Functional Programming | Cambridge Core

Checking equivalence in a non-strict language - Volume 35

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Turner, Bird, Eratosthenes: An eternal burning thread. ~ Jeremy Gibbons. cambridge.org/core/journals/jo

cambridge.org

Turner, Bird, Eratosthenes: An eternal burning thread | Journal of Functional Programming | Cambridge Core

Turner, Bird, Eratosthenes: An eternal burning thread - Volume 35

Andres Löh
@kosmikus@functional.cafe

There's going to be a new episode of the today, 2025-11-12, at 1930 UTC. We're going to discuss how to implement (more) type-safe APIs via some type-level programming using the sop-core package.

youtube.com/watch?v=3XeIoA0aVL

youtube.com

Typed servers using sop-core (Haskell Unfolder #51)

In this episode we consider how we can design a typed client/server interface for a simple API. We will use this as an introduction to some of the foundation...

HaskellOrg
@haskell@fosstodon.org

It's with great pleasure that we are announcing that @upcloud is sponsoring the project, by providing high-performance CI infrastructure for the Glasgow Haskell Compiler! Thank you!

Abhinav 🧭
@abnv@fantastic.earth

Would people be interested in a series of posts where I implement the C from "Writing a C Compiler" book by Nora Sandler in ? I'd focus on Haskell specific libraries and techniques with some additional bits not present in the book.

  • Yes21 (84%)
  • No3 (12%)
  • I hate book implementations1 (4%)
José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared November 7, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared November 7, 2025

The readings shared in Bluesky on 7 November 2025 are: An introduction to formal real analysis (Lecture 16: Completeness of the real numbers). ~ Alex Kontorovich. #ITP #LeanProver #Math The path to a

Fraser Tweedale
@hackuador@functional.cafe

Great lineup for Brisbane Functional Programming Group next Tuesday November 11!

- Serializotron: zero-boilerplate serialisation for (Carlo Hamalainen)
- tmefunc: syntactic sugar for in (T. Mark Ellison and Siva Kalyan)

luma.com/kq933nnz

This is our final regular session for 2025, with a social event planned for December. Be there or be a lambda cube!

luma.com

BFPG Meetup - November 2025 - Serializotron + FP in Python · Luma

Join the BFPG Discord: https://discord.gg/yYz2d8w7FY Agenda 18:00: Welcome and setup Presentation #1: Serializotron: Protobuf‑Backed, Zero‑Boilerplate…

Abhinav 🧭
@abnv@fantastic.earth · Reply to Abhinav 🧭

Interesting poll results! I didn't expect Attoparsec to go toe-to-toe with Megaparsec.

So I did some digging into based programming language projects on Github, and here's what I found (lexer and parser mentioned separately, if different):

- Purescript: handwritten + Happy
- Elm: handwritten
- Agda: Alex + Happy
- Dex: Megaparsec
- Carp: Parsec
- Dhall: Megaparsec
- Grace: Megaparsec + Earley
- Plutus: Megaparsec
- Grin: Megaparsec
- Futhark: Alex + Happy
- Granule / Gerty: Alex + Happy
- Kaleidoscope: Parsec
- Egison: Megaparsec
- Amulet: Alex + Happy
- Paskell: Parsec
- Facet: Handwritten + Parsec
- Eclair: Megaparsec
- Olifant: Megaparsec
- Shellcheck: Parsec
- Nixfmt: Megaparsec

It seems like Megaparsec is the clear winner when it comes to parsing programming languages in Haskell. However, if I focus on projects that parse file formats and network protocols, Attoparsec is the most popular one.

Abhinav 🧭
@abnv@fantastic.earth · Reply to Abhinav 🧭

Interesting poll results! I didn't expect Attoparsec to go toe-to-toe with Megaparsec.

So I did some digging into based programming language projects on Github, and here's what I found (lexer and parser mentioned separately, if different):

- Purescript: handwritten + Happy
- Elm: handwritten
- Agda: Alex + Happy
- Dex: Megaparsec
- Carp: Parsec
- Dhall: Megaparsec
- Grace: Megaparsec + Earley
- Plutus: Megaparsec
- Grin: Megaparsec
- Futhark: Alex + Happy
- Granule / Gerty: Alex + Happy
- Kaleidoscope: Parsec
- Egison: Megaparsec
- Amulet: Alex + Happy
- Paskell: Parsec
- Facet: Handwritten + Parsec
- Eclair: Megaparsec
- Olifant: Megaparsec
- Shellcheck: Parsec
- Nixfmt: Megaparsec

It seems like Megaparsec is the clear winner when it comes to parsing programming languages in Haskell. However, if I focus on projects that parse file formats and network protocols, Attoparsec is the most popular one.

Abhinav 🧭
@abnv@fantastic.earth · Reply to Abhinav 🧭

Interesting poll results! I didn't expect Attoparsec to go toe-to-toe with Megaparsec.

So I did some digging into based programming language projects on Github, and here's what I found (lexer and parser mentioned separately, if different):

- Purescript: handwritten + Happy
- Elm: handwritten
- Agda: Alex + Happy
- Dex: Megaparsec
- Carp: Parsec
- Dhall: Megaparsec
- Grace: Megaparsec + Earley
- Plutus: Megaparsec
- Grin: Megaparsec
- Futhark: Alex + Happy
- Granule / Gerty: Alex + Happy
- Kaleidoscope: Parsec
- Egison: Megaparsec
- Amulet: Alex + Happy
- Paskell: Parsec
- Facet: Handwritten + Parsec
- Eclair: Megaparsec
- Olifant: Megaparsec
- Shellcheck: Parsec
- Nixfmt: Megaparsec

It seems like Megaparsec is the clear winner when it comes to parsing programming languages in Haskell. However, if I focus on projects that parse file formats and network protocols, Attoparsec is the most popular one.

Abhinav 🧭
@abnv@fantastic.earth · Reply to Abhinav 🧭

Interesting poll results! I didn't expect Attoparsec to go toe-to-toe with Megaparsec.

So I did some digging into based programming language projects on Github, and here's what I found (lexer and parser mentioned separately, if different):

- Purescript: handwritten + Happy
- Elm: handwritten
- Agda: Alex + Happy
- Dex: Megaparsec
- Carp: Parsec
- Dhall: Megaparsec
- Grace: Megaparsec + Earley
- Plutus: Megaparsec
- Grin: Megaparsec
- Futhark: Alex + Happy
- Granule / Gerty: Alex + Happy
- Kaleidoscope: Parsec
- Egison: Megaparsec
- Amulet: Alex + Happy
- Paskell: Parsec
- Facet: Handwritten + Parsec
- Eclair: Megaparsec
- Olifant: Megaparsec
- Shellcheck: Parsec
- Nixfmt: Megaparsec

It seems like Megaparsec is the clear winner when it comes to parsing programming languages in Haskell. However, if I focus on projects that parse file formats and network protocols, Attoparsec is the most popular one.

Abhinav 🧭
@abnv@fantastic.earth

Which is your favourite parsing library and why?

  • Parsec2 (25%)
  • ReadP0 (0%)
  • Attoparsec1 (13%)
  • Megaparsec4 (50%)
  • Alex + Happy0 (0%)
  • Flatparse1 (13%)
  • Earley0 (0%)
  • Parsley0 (0%)
  • Streamly0 (0%)
  • Polyparse0 (0%)
José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared November 2, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared November 2, 2025

The readings shared in Bluesky on 2 November 2025 are: "Why don't you use dependent types?" ~ Lawrence Paulson. #ITP #Automath #LCF #IsabelleHOL #LeanProver #TypeTheory Lean4Physics: Comprehensive re

Abhinav 🧭
@abnv@fantastic.earth

Which is your favourite parsing library and why?

  • Parsec2 (25%)
  • ReadP0 (0%)
  • Attoparsec1 (13%)
  • Megaparsec4 (50%)
  • Alex + Happy0 (0%)
  • Flatparse1 (13%)
  • Earley0 (0%)
  • Parsley0 (0%)
  • Streamly0 (0%)
  • Polyparse0 (0%)
José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared October 31, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared October 31, 2025

The readings shared in Bluesky on 31 October 2025 are: Virasoro algebra and Sugawara constructions formally in Lean. ~ Kalle Kytölä. #ITP #LeanProver #Math Derivation of fundamental physical constant

Ben Gamari
@bgamari@mastodon.social

After a long wait, GHC 9.14.1-rc1 is now available. This includes an important fix which ensures compatibility with macOS 26 and later. We expect that this same fix will be backported to GHC 9.12 and 9.10 in the coming months.

Happy Haskelling!

https:/ /www.haskell.org/ghc/blog/20251030-ghc-9.14.1-rc1-released.html

Ben Gamari
@bgamari@mastodon.social

After a long wait, GHC 9.14.1-rc1 is now available. This includes an important fix which ensures compatibility with macOS 26 and later. We expect that this same fix will be backported to GHC 9.12 and 9.10 in the coming months.

Happy Haskelling!

https:/ /www.haskell.org/ghc/blog/20251030-ghc-9.14.1-rc1-released.html

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared October 29, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared October 29, 2025

The readings shared in Bluesky on 29 October 2025 are: Formalizing Schwartz functions and tempered distributions. ~ Moritz Doll. #ITP #LeanProver #Math 1000+ theorems (The spiritual successor of Free

Andres Löh
@kosmikus@functional.cafe

Join us tonight for the 50th (!) episode of the , on singletons! Live on YouTube 1930 UTC (note the changed time in some countries due to DST-related fluctuations).

youtube.com/watch?v=-zxxl-Wuwu

youtube.com

Singletons (Haskell Unfolder #50)

When writing functions involving GADTs in Haskell, we sometimes have to resort to a concept known as singletons. Such singletons build a bridge between the t...

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared October 28, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared October 28, 2025

The readings shared in Bluesky on 28 October 2025 are: Formalization of Walsh-Fourier series. ~ Izabela Maria Mandla. #ITP #LeanProver #Math Towards a verified compiler for Distributed PlusCal. ~ Ghi

HaskellOrg
@haskell@fosstodon.org

This is not a drill: GHC (the compiler) now runs in your browser. See the announcement (and please report any bugs) here: discourse.haskell.org/t/ghc-no

discourse.haskell.org

Ghc now runs in your browser

ghc itself can now run purely client-side in the browser, here’s a haskell playground demo. terms and conditions apply, and i’ll write up more detailed explanation some time later, but i thought this is a cool thing to show off how far the ghc wasm backend has advanced 🙂

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared October 22, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared October 22, 2025

The readings shared in Bluesky on 22 October 2025 are: Formal or not formal? That is the question in AI for theorem proving. ~ Kevin Buzzard. #AI #Math #LLM #ITP #LeanProver Formalisation of the Cald

HaskellOrg
@haskell@fosstodon.org

Call for Servant cookbooks in preparation of v0.21

discourse.haskell.org/t/call-f

discourse.haskell.org

Call for Servant cookbooks in preparation of v0.21

Hi everyone, as a maintainer of Servant, I would like to call to its user base to share some of the techniques that you may have developed in your applications over the years. As you know, Servant is rather principled, and it’s not always easy to reflect the complexity of the outside world in this principled framework. While we are lucky to have recently received contributions from industrial users, like MultiVerb, it remains that more documentation on the techniques that are in use is very we...

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared October 21, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared October 21, 2025

The readings shared in Bluesky on 21 October 2025 are: HITrees: Higher-order interaction trees. ~ Amir Mohammad Fadaei Ayyam, Michael Sammler. #ITP #LeanProver Certifying optimal MEV strategies with

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared October 20, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared October 20, 2025

The readings shared in Bluesky on 20 October 2025 are: Formalizing Wigner’s semicircle law in Lean. ~ Haoyan Jiang et als. #ITP #LeanProver #Math Towards verifying the "Three amigos". ~ Carl Kwan. #I

Abhinav 🧭
@abnv@fantastic.earth

I've written a series of blog posts, in which I write a and a for arithmetic in . We explore the following topics in the series:

- Parsing arithmetic expressions to ASTs.
- Compiling ASTs to bytecode.
- Interpreting ASTs.
- Efficiently executing bytecode in a VM.
- Disassembling bytecode and decompiling opcodes for debugging and testing.
- Unit testing and property-based testing for our compiler and VM.
- Benchmarking our code to see how the different passes perform.
- All the while keeping an eye on performance.

The third and final post of the series that focuses on writing the virtual machine is now out: abhinavsarkar.net/posts/arithm

abhinavsarkar.net

A Fast Bytecode VM for Arithmetic: The Virtual Machine

We write a fast bytecode VM for arithmetic in Haskell.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared October 17, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared October 17, 2025

The readings shared in Bluesky on 17 October 2025 are: A formalization of Borel determinacy in Lean. ~ Sven Manthe. #ITP #LeanProver #Math Yalep: An environment for learning proof in high-school. ~ F

DiazCarrete
@DiazCarrete@hachyderm.io

Rebound: Efficient, Expressive, and Well-Scoped Binding
youtu.be/IlQQElKaFvM?t=1448
reddit.com/r/haskell/comments/
arxiv.org/abs/2509.13261

arxiv.org

Rebound: Efficient, Expressive, and Well-Scoped Binding

We introduce the Rebound library that supports well-scoped term representations in Haskell and automates the definition of substitution, alpha-equivalence, and other operations that work with binding structures. The key idea of our design is the use of first-class environments that map variables to expressions in some new scope. By statically tracking scopes, users of this library gain confidence that they have correctly maintained the subtle invariants that stem from using de Bruijn indices. Behind the scenes, Rebound uses environments to optimize the application of substitutions, while providing explicit access to these data structures when desired. We demonstrate that this library is expressive by using it to implement a wide range of language features with sophisticated uses of binding and several different operations that use this abstract syntax. Our examples include pi-forall, a tutorial implementation of a type checker for a dependently-typed programming language. Finally, we benchmark Rebound to understand its performance characteristics and find that it produces faster code than competing libraries.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

: Actualización de ejercicios del curso 2014-15. jaalonso.github.io/exercitium/

jaalonso.github.io

Actualización de ejercicios del curso 2014-15

Con la próxima entrada se inicia la actualización de los ejercicios del curso 2014-15. ¿En qué consiste la actualización? Cada ejercicio será mejorado mediante las siguientes acciones: Ampliación de

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared October 16, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared October 16, 2025

The readings shared in Bluesky on 16 October 2025 are: Most proofs are trivial. ~ Lawrence Paulson. #Math #ITP #IsabelleHOL An introduction to formal real analysis (Lecture 11: The real numbers I). ~

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared October 15, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared October 15, 2025

The readings shared in Bluesky on 15 October 2025 are: Rely-guarantee verification of queue locks with proof support in Isabelle/HOL. ~ Robert J. Colvin, Scott Heiner, Peter Höfner, Roger C. Su. #ITP

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared October 14, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared October 14, 2025

The readings shared in Bluesky on 14 October 2025 are: Formally verified certification of unsolvability of temporal planning problems. ~ David Wang, Mohammad Abdulaziz. #ITP #IsabelleHOL A formalizat

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared October 13, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared October 13, 2025

The readings shared in Bluesky on 13 October 2025 are: PVS formalization of proofs of the infinitude of primes. ~ Bruno Berto de Oliveira Ribeiro. #ITP #PVS #Math Certified decision procedures for wi

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared October 10, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared October 9, 2025

The readings shared in Bluesky on 9 October 2025 are: State management in Haskell. ~ Ajeet Grewal. #Haskell #FunctionalProgramming Haskell is the perfect fit for renewable energy tech. ~ Marc Jakobi.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared October 7, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared October 7, 2025

The readings shared in Bluesky on 7 October 2025 are: A formally verified IEEE 754 floating-point implementation of interval iteration for MDPs. ~ Bram Kohlen, Maximilian Schäffeler, Mohammad Abdulaz

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared October 6, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared October 6, 2025

The readings shared in Bluesky on 6 October 2025 are: An introduction to formal real analysis (Lecture 8: Advanced limit theorems and induction). ~ Alex Kontorovich. #ITP #LeanProver #Math Formal ver

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared October 3, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared October 03, 2025

The readings shared in Bluesky on 03 October 2025 are: Kevin Buzzard and Alex Kontorovich on the future of formal mathematics: A Mathlib initiative interview. ~ Oliver Nash. #ITP #LeanProver #Mathlib

Andres Löh
@kosmikus@functional.cafe

After a long summer break, we're finally back for a new episode of the : Edsko and I are going to talk about safe coercions, newtype vs data, roles and more ... Today, 2025-10-01, 1830 UTC on YouTube: youtube.com/watch?v=NC0wkFsVPD

youtube.com

Safe coercions (Haskell Unfolder #48)

When GHC knows that two types have the same run-time representation, it allows you to use coerce to go from a value of one to a value of the other in a safe ...

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared September 29, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared September 29, 2025

The readings shared in Bluesky on 29 September 2025 are: A new proof for soundness of right-forward closures for termination analysis. ~ René Thiemann. #ITP #IsabelleHOL Core matrix interpretations f

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared September 28, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared September 28, 2025

The readings shared in Bluesky on 28 September 2025 are: Nondeterministic asynchronous dataflow in Isabelle/HOL. ~ Rafael Castro Gonçalves Silva, Laouen Fernet, Dmitriy Traytel. #ITP #IsabelleHOL For

pandoc
@pandoc@fosstodon.org

Looking for a LaTeX symbol, but don't know the command to produce it?
detexify.kirelabs.org can help. Draw the symbol, and the app will produce a list of matching symbols.

Incidentally, the tool is written in , just like .

Video showing a how the partial differential symbol ∂ is drawn in a box (badly), and with the tool responding with a list of LaTeX commands after a short wait.
ALT text

Video showing a how the partial differential symbol ∂ is drawn in a box (badly), and with the tool responding with a list of LaTeX commands after a short wait.

Video showing a how the partial differential symbol ∂ is drawn in a box (badly), and with the tool responding with a list of LaTeX commands after a short wait.
ALT text

Video showing a how the partial differential symbol ∂ is drawn in a box (badly), and with the tool responding with a list of LaTeX commands after a short wait.

pandoc
@pandoc@fosstodon.org

Looking for a LaTeX symbol, but don't know the command to produce it?
detexify.kirelabs.org can help. Draw the symbol, and the app will produce a list of matching symbols.

Incidentally, the tool is written in , just like .

Video showing a how the partial differential symbol ∂ is drawn in a box (badly), and with the tool responding with a list of LaTeX commands after a short wait.
ALT text

Video showing a how the partial differential symbol ∂ is drawn in a box (badly), and with the tool responding with a list of LaTeX commands after a short wait.

Video showing a how the partial differential symbol ∂ is drawn in a box (badly), and with the tool responding with a list of LaTeX commands after a short wait.
ALT text

Video showing a how the partial differential symbol ∂ is drawn in a box (badly), and with the tool responding with a list of LaTeX commands after a short wait.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared September 23, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared September 23, 2025

The readings shared in Bluesky on 23 September 2025 are: Formalising new mathematics in Isabelle: Diagonal Ramsey. ~ Lawrence C. Paulson. #ITP #IsabelleHOL #Math A formal analysis of algorithms for m

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared September 22, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared September 22, 2025

The readings shared in Bluesky on 22 September 2025 are: Formalizing dimensional analysis using the Lean theorem prover. ~ Maxwell P. Bobbin et als. #ITP #LeanProver Computationally-sound symbolic cr

DiazCarrete
@DiazCarrete@hachyderm.io

Formalising Graph Algorithms with Coinduction
discourse.haskell.org/t/a-hask

discourse.haskell.org

A Haskell representation of Graphs

My supervisor and I wrote a paper on functional graphs last year, and in it we advocated for using the simple a → [a] type for graphs ( POPL Paper—Formalising Graph Algorithms with Coinduction - Donnacha Oisín Kidney ). Of course, there are always tradeoffs with different representations, so this representation isn’t perfect for everything (it’s good for simple search algorithms). I think it’s a good default, though. There’s also been a lot of other work over the past few years on graph repres...

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Refinement-types driven development: A study. ~ Facundo Domínguez, Arnaud Spiwack. arxiv.org/abs/2509.15005v1

arxiv.org

Refinement-Types Driven Development: A study

This paper advocates for the broader application of SMT solvers in everyday programming, challenging the conventional wisdom that these tools are solely for formal methods and verification. We claim that SMT solvers, when seamlessly integrated into a compiler's static checks, significantly enhance the capabilities of ordinary type checkers in program composition. Specifically, we argue that refinement types, as embodied by Liquid Haskell, enable the use of SMT solvers in mundane programming tasks. Through a case study on handling binder scopes in compilers, we envision a future where ordinary programming is made simpler and more enjoyable with the aid of refinement types and SMT solvers. As a secondary contribution, we present a prototype implementation of a theory of finite maps for Liquid Haskell's solver, developed to support our case study.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Refinement-types driven development: A study. ~ Facundo Domínguez, Arnaud Spiwack. arxiv.org/abs/2509.15005v1

arxiv.org

Refinement-Types Driven Development: A study

This paper advocates for the broader application of SMT solvers in everyday programming, challenging the conventional wisdom that these tools are solely for formal methods and verification. We claim that SMT solvers, when seamlessly integrated into a compiler's static checks, significantly enhance the capabilities of ordinary type checkers in program composition. Specifically, we argue that refinement types, as embodied by Liquid Haskell, enable the use of SMT solvers in mundane programming tasks. Through a case study on handling binder scopes in compilers, we envision a future where ordinary programming is made simpler and more enjoyable with the aid of refinement types and SMT solvers. As a secondary contribution, we present a prototype implementation of a theory of finite maps for Liquid Haskell's solver, developed to support our case study.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared September 18, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared September 18, 2025

The readings shared in Bluesky on 18 September 2025 are: Case study: Verified Vampire proofs in the lambdapi-calculus modulo. ~ Anja Petković Komel, Michael Rawson, Martin Suda. #ATP #Vampire #ITP #D

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared September 17, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared September 17, 2025

The readings shared in Bluesky on 17 September 2025 are: Formalizing dimensional analysis using the Lean theorem prover. ~ Maxwell P. Bobbin, Colin Jones, John Velkey, Tyler R. Josephson. #ITP #LeanP

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared September 5, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared September 5, 2025

The readings shared in Bluesky on 5 September 2025 are Program verification is not all-or-nothing. ~ Lawrence Paulson. #FormalVerification The future of math is programming. ~ Ank Yog. #ITP #LeanProv

HaskellOrg
@haskell@fosstodon.org

"Monad of No Return: Next Steps" discourse.haskell.org/t/monad-

discourse.haskell.org

Monad of No Return: Next Steps

The proposal monad of no return has been in the process of being implemented for a while. I’m collecting community feedback on the proposal (and specifically phase 3) in the hopes that as a community we can move forwards in making Haskell a better language. I encourage people to read the proposal above, but I’ll summarise and quote below where relevant. What is this proposal? The proposal outlines that with making Applicative a superclass of Monad (which happened with Functor-Applicative-Monad ...

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared September 4, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared September 4, 2025

The readings shared in Bluesky on 4 September 2025 are F91 in Lean. ~ Joachim Breitner. #ITP #LeanProver Lean: First steps. ~ Tariq Rashid. #ITP #LeanProver Acorn and the future of (AI?) theorem prov

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared September 3, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared September 3, 2025

The readings shared in Bluesky on 3 September 2025 are Thinking programs (Logical modeling and reasoning about languages, data, computations, and executions). ~ Wolfgang Schreiner. #ITP #IsabelleHOL

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared September 2, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared September 2, 2025

The readings shared in Bluesky on 2 September 2025 are Aspects of category theory in proof assistants. ~ Luc Chabassier. #ITP #CoqProver #CategoryTheory No-free-lunch theorem for machine learning. ~

HaskellOrg
@haskell@fosstodon.org

New kid on the block: Granite is the new terminal plotting library from ‪‬@mchav's dataframe project

discourse.haskell.org/t/granit

github.com/mchav/granite

github.com

GitHub - mchav/granite: A library for producing terminal plots.

A library for producing terminal plots. Contribute to mchav/granite development by creating an account on GitHub.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared September 1, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared September 1, 2025

The readings shared in Bluesky on 1 September 2025 are Growing Mathlib: maintenance of a large scale mathematical library. ~ Anne Baanen et als. #ITP #LeanProver #Mathlib Starting out with graph algo

Brent Yorgey
@byorgey@mathstodon.xyz

The folks at finally published the problems from a bunch of old contests that they have hosted over the years, including quite a few that I helped organize. Yay! (I have been bugging them to do this literally for years.) In particular, the list of available problems written by me instantly went from 2 to about 35:

open.kattis.com/problem-author

I have solved many (though not all) of them in . Give them a try and let me know what you think! 😄

open.kattis.com

Problems by Brent Yorgey – Kattis, Kattis

Fraser Tweedale
@hackuador@functional.cafe

Two AMAZING talks for the Brisbane Functional Programming Group September 9th meetup:

• ​Typed Holes and Hole-driven Development (George Wilson)
• ​'s Type-Safe OTP Concurrency: A New Era of Reliable Distributed Programming (Cameron Badman)

luma.com/kukbikp7

lu.ma

BFPG Meetup - September 2025 - Hole-driven development + Gleam · Luma

Join the BFPG Discord: https://discord.gg/yYz2d8w7FY Agenda 18:00: Welcome and setup Presentation #1: Typed Holes and Hole-driven Development - George…

Brent Yorgey
@byorgey@mathstodon.xyz

The folks at finally published the problems from a bunch of old contests that they have hosted over the years, including quite a few that I helped organize. Yay! (I have been bugging them to do this literally for years.) In particular, the list of available problems written by me instantly went from 2 to about 35:

open.kattis.com/problem-author

I have solved many (though not all) of them in . Give them a try and let me know what you think! 😄

open.kattis.com

Problems by Brent Yorgey – Kattis, Kattis

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

: Elementos de una matriz con algún vecino menor. jaalonso.github.io/exercitium/

jaalonso.github.io

Elementos de una matriz con algún vecino menor

Las matrices puede representarse mediante tablas cuyos índices son pares de números naturales. Su tipo se define por type Matriz = Array (Int,Int) Int Por ejemplo, la matriz |9 4 6 5| |8 1 7 3| |4 2

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

: Número de pares de elementos adyacentes iguales en una matriz. jaalonso.github.io/exercitium/

jaalonso.github.io

Número de pares de elementos adyacentes iguales en una matriz

Una matriz se puede representar mediante una lista de listas. Por ejemplo, la matriz |2 1 5| |4 3 7| se puede representar mediante la lista [[2,1,5],[4,3,7]] Definir la función numeroParesAdyacent

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

: Elemento más repetido de manera consecutiva. jaalonso.github.io/exercitium/

jaalonso.github.io

Elemento más repetido de manera consecutiva

Definir la función masRepetido :: Ord a => [a] -> (a,Int) tal que (masRepetido xs) es el elemento de xs que aparece más veces de manera consecutiva en la lista junto con el número de sus apariciones

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

: Numeración de las ternas de números naturales. jaalonso.github.io/exercitium/

jaalonso.github.io

Numeración de las ternas de números naturales

Las ternas de números naturales se pueden ordenar como sigue (0,0,0), (0,0,1),(0,1,0),(1,0,0), (0,0,2),(0,1,1),(0,2,0),(1,0,1),(1,1,0),(2,0,0), (0,0,3),(0,1,2),(0,2,1),(0,3,0),(1,0,2),(1,1,1),(1,2,0),

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

: Valores de polinomios representados con vectores. jaalonso.github.io/exercitium/

jaalonso.github.io

Valores de polinomios representados con vectores

Los polinomios se pueden representar mediante vectores usando la librería Data.Array. En primer lugar, se define el tipo de los polinomios (con coeficientes de tipo a) mediante type Polinomio a = Arra

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

: Segmentos maximales con elementos consecutivos. jaalonso.github.io/exercitium/

jaalonso.github.io

Segmentos maximales con elementos consecutivos

Definir la función segmentos :: (Enum a, Eq a) => [a] -> [[a]] tal que (segmentos xss) es la lista de los segmentos de xss formados por elementos consecutivos. Por ejemplo, segmentos [1,2,5,6,4]

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared August 26, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared August 26, 2025

The readings shared in Bluesky on 26 August 2025 are Experimental results for Vampire on the equational theories project. ~ Mikoláš Janota. #ATP #Vampire Lean meets theoretical computer science: Scal

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared August 25, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared August 25, 2025

The readings shared in Bluesky on 25 August 2025 are Visualizing regular expression NFAs in Lean. ~ Krishna Padmasola. #ITP #LeanProver A case study on the effectiveness of LLMs in verification with

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

: Primos consecutivos con media capicúa. jaalonso.github.io/exercitium/

jaalonso.github.io

Primos consecutivos con media capicúa

Definir la función primosConsecutivosConMediaCapicua :: [(Int,Int,Int)] formada por las ternas (x,y,z) tales que x e y son primos consecutivos cuya media, z, es capicúa. Por ejemplo, λ> take 5 primo

Abhinav 🧭
@abnv@fantastic.earth

I'm writing a series of blog posts, in which I write a and a for arithmetic in . We explore the following topics in the series:

- Parsing arithmetic expressions to ASTs.
- Compiling ASTs to bytecode.
- Interpreting ASTs.
- Efficiently executing bytecode in a VM.
- Disassembling bytecode and decompiling opcodes for debugging and testing.
- Unit testing and property-based testing for our compiler and VM.
- Benchmarking our code to see how the different passes perform.
- All the while keeping an eye on performance.

The second post of the series that focuses on writing the is now out: abhinavsarkar.net/posts/arithm

abhinavsarkar.net

A Fast Bytecode VM for Arithmetic: The Compiler

We write a fast bytecode VM for arithmetic in Haskell.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

To zip through the cost analysis of probabilistic programs. ~ Matthias Hetzenberger, Georg Moser, Florian Zuleger. arxiv.org/abs/2508.14249v1

arxiv.org

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 encoding probabilistic behaviour directly in types. Initially defined for discrete distributions over finite support, it is extended to support infinite distributions via an axiomatic approach. By leveraging Liquid Haskell's SMT-based refinement type checking, our framework provides a high degree of automation. We evaluate our approach through four case studies: meldable heaps, coupon collector, randomised quicksort, and zip trees. The first two demonstrate automation with minimal annotation overhead. The latter two showcase how our monad integrates with interactive proofs, including the first formal verification of the expected runtime of zip trees.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

: Determinación de los elementos minimales. jaalonso.github.io/exercitium/

jaalonso.github.io

Determinación de los elementos minimales

Definir la función minimales :: Eq a => [[a]] -> [[a]] tal que (minimales xss) es la lista de los elementos de xss que no están contenidos en otros elementos de xss. Por ejemplo, minimales [[1,3],[2

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

The Baby paradox in Haskell. ~ Justin Le. blog.jle.im/entry/the-baby-par

blog.jle.im

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.

mdrslmr
@mdrslmr@sciences.social · Reply to HaskellOrg

@haskell

Great introduction.

I tried to get the hls , with coc in vim running.

I tried the eval in a comment, like
-- >>> 2 + 2
How to invoke the evaluation?
Do I have to click or press a key?

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared August 18, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared August 18, 2025

The readings shared in Bluesky on 18 August 2025 are Formalizing axiomatics for first-order logic. ~ Jørgen Villadsen, Simon Tobias Lund, Anders Schlichtkrull. #ITP #IsabelleHOL #Logic Formal correct

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Invertible syntax without the tuples (Functional Pearl). ~ Mathieu Boespflug, Arnaud Spiwack. arxiv.org/abs/2508.09856v1

arxiv.org

Invertible Syntax without the Tuples (Functional Pearl)

In the seminal paper Functional unparsing, Olivier Danvy used continuation passing to reanalyse printf-like format strings as combinators. In the intervening decades, the conversation shifted towards a concurrent line of work -- applicative, monadic or arrow-based combinator libraries -- in an effort to find combinators for invertible syntax descriptions that simultaneously determine a parser as well as a printer, and with more expressive power, able to handle inductive structures such as lists and trees. Along the way, continuation passing got lost. This paper argues that Danvy's insight remains as relevant to the general setting as it was to the restricted setting of his original paper. Like him, we present three solutions that exploit continuation-passing style as an alternative to both dependent types and monoidal aggregation via nested pairs, in our case to parse and print structured data with increasing expressive power.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Invertible syntax without the tuples (Functional Pearl). ~ Mathieu Boespflug, Arnaud Spiwack. arxiv.org/abs/2508.09856v1

arxiv.org

Invertible Syntax without the Tuples (Functional Pearl)

In the seminal paper Functional unparsing, Olivier Danvy used continuation passing to reanalyse printf-like format strings as combinators. In the intervening decades, the conversation shifted towards a concurrent line of work -- applicative, monadic or arrow-based combinator libraries -- in an effort to find combinators for invertible syntax descriptions that simultaneously determine a parser as well as a printer, and with more expressive power, able to handle inductive structures such as lists and trees. Along the way, continuation passing got lost. This paper argues that Danvy's insight remains as relevant to the general setting as it was to the restricted setting of his original paper. Like him, we present three solutions that exploit continuation-passing style as an alternative to both dependent types and monoidal aggregation via nested pairs, in our case to parse and print structured data with increasing expressive power.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared August 15, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared August 15, 2025

The readings shared in Bluesky on 15 August 2025 are Definite integrals, I: easy cases over finite intervals. ~ Lawrence Paulson. #ITP #IsabelleHOL #Math Revisiting the Fast Fourier Transform in Rocq

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared August 13, 2025. jaalonso.github.io/vestigium/p ACL2

jaalonso.github.io

Readings shared August 13, 2025

The readings shared in Bluesky on 13 August 2025 are In-order traversal in Haskell and Rust. ~ James Bowen. #Haskell #FunctionalProgramming #RustLang First analysis lecture (June 16, 2025). ~ Alex Ko

HaskellOrg
@haskell@fosstodon.org

"RFC: Introduce a serialisable bytecode format"

discourse.haskell.org/t/rfc-in

discourse.haskell.org

RFC: Introduce a serialisable bytecode format and corresponding "bytecode" way

We are planning on adding a new “bytecode” way, to enable the persisting and packaging of bytecode artifacts. At this stage it would be useful to gather feedback from any interested parties on the proposed interface for the design. Please leave comments on this thread or on the GHC tracking ticket if you have any questions or suggestions. GHC’s bytecode interpreter is widely used in GHCi and for Template Haskell evaluation with (-fprefer-bytecode), but until now it has only ever generated tra...

Fraser Tweedale
@hackuador@functional.cafe

Brisbane Functional Programming Group tomorrow Tue 12th! Explicit Substitutions pt2 (Donovan Crichton) + Overview of flake-parts and -flake (Jack Kelly). Be there or be a lambda cube! lu.ma/r002tby5

lu.ma

BFPG Meetup - August 2025 - Explicit Substitutions pt2 + Nix Flakes · Luma

Agenda 18:00: Welcome and setup Presentation #1: Explicit Substitutions Part 2 - Donovan Crichton Presentation #2: Overview of flake-parts and haskell-flake -…

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared August 10, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared August 10, 2025

The readings shared in Bluesky on 10 August 2025 are A practical formalization of monadic equational reasoning in dependent-type theory. ~ Reynald Affeldt, Jacques Garrigue, Takafumi Saikawa, #ITP #

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared August 9, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared August 9, 2025

The readings shared in Bluesky on 9 August 2025 are Mission-time Linear Temporal Logic Formula Progression (in Isabelle/HOL). ~ Katherine Kosaian, Zili Wang. #ITP #IsabelleHOL Two-way deterministic f

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Teaching introductory functional programming using Haskelite. ~ Pedro Vasconcelos. arxiv.org/abs/2508.03640

arxiv.org

Teaching Introductory Functional Programming Using Haskelite

Learning functional programming requires learning a substitution-based computational model. While substitution should be a familiar concept from high-school algebra, students often have difficulty applying it to new settings, such as recursive definitions, algebraic data types and higher-order functions. Step-by-step interpreters have been shown to help beginners by clarifying misconceptions and improving understanding. This paper reports on the experience of using a step-by-step tracing interpreter for a subset of Haskell while teaching an introductory functional programming course at the University of Porto. We describe the use of the interpreter, present some feedback obtained from students, reflect on the lessons learned and point directions for further work.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Teaching introductory functional programming using Haskelite. ~ Pedro Vasconcelos. arxiv.org/abs/2508.03640

arxiv.org

Teaching Introductory Functional Programming Using Haskelite

Learning functional programming requires learning a substitution-based computational model. While substitution should be a familiar concept from high-school algebra, students often have difficulty applying it to new settings, such as recursive definitions, algebraic data types and higher-order functions. Step-by-step interpreters have been shown to help beginners by clarifying misconceptions and improving understanding. This paper reports on the experience of using a step-by-step tracing interpreter for a subset of Haskell while teaching an introductory functional programming course at the University of Porto. We describe the use of the interpreter, present some feedback obtained from students, reflect on the lessons learned and point directions for further work.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared August 8, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared August 8, 2025

The readings shared in Bluesky on 8 August 2025 are Discrete mathematics with Lean 4. ~ Shrey Vivek./#/g/shreyvivek/gamemaker #ITP #LeanProver #Math Gödel's incompleteness theorem. ~ Thorsten Altenki

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

: Haskell software engineer for remote position at IOG (Input Output Global). tinyurl.com/23x85sha

discourse.haskell.org

Haskell Software Engineer for Remote Position

Company Overview IOG (Input Output Global) is a pioneering company in blockchain technology, recognized for its scientific and research-driven approach. The organization focuses on advancing decentralized finance (DeFi), digital governance, and identity solutions through peer-reviewed methodologies and secure, scalable, and sustainable blockchain systems. IOG operates as a fully decentralized entity, empowering innovation through a globally distributed team across more than 50 countries. Positi...

HaskellOrg
@haskell@fosstodon.org · Reply to HaskellOrg

The talks of the 2025 Haskell Implementor's Workshop, also co-located with @zurihac are available on YouTube: youtube.com/playlist?list=PLQp


youtube.com

2025 Haskell Implementors' Workshop

The 17th Haskell Implementors’ Workshop was held on June 6th 2025 alongside ZuriHac and the Haskell Ecosystom Workshop near Zurich. The event was organized b...

DiazCarrete
@DiazCarrete@hachyderm.io

"Overloading harms type inference, so undesirable"

"OverloadedLists harms hole-driven development."

youtube.com/watch?v=CCDz-_aq5g

I wonder what the presenter thinks about the QualifiedLiterals GHC proposal github.com/ghc-proposals/ghc-p In a way, that proposal aims to tame Overloaded-type extensions.

Slide with the line "Overloading harms type inference, so undesirable"
ALT text

Slide with the line "Overloading harms type inference, so undesirable"

A slide with the title "OverloadedLists" harms hole-driven development.
ALT text

A slide with the title "OverloadedLists" harms hole-driven development.

Abhinav 🧭
@abnv@fantastic.earth

I'm starting a series of blog posts, in which I write a and a for arithmetic in . We explore the following topics in the series:

- Parsing arithmetic expressions to ASTs.
- Compiling ASTs to bytecode.
- Interpreting ASTs.
- Efficiently executing bytecode in a VM.
- Disassembling bytecode and decompiling opcodes for debugging and testing.
- Unit testing and property-based testing for our compiler and VM.
- Benchmarking our code to see how the different passes perform.
- All the while keeping an eye on performance.

The first post of the series that focuses on writing the is now out: abhinavsarkar.net/posts/arithm

abhinavsarkar.net

A Fast Bytecode VM for Arithmetic: The Parser

We write a fast bytecode VM for arithmetic in Haskell.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Fixed-point-oriented programming: A concise and elegant paradigm. ~ Yong Qi Foo, Brian Sze-Kai Cheong, Michael D. Adams. arxiv.org/abs/2507.21439v1

arxiv.org

Fixed-Point-Oriented Programming: A Concise and Elegant Paradigm

Fixed-Point-Oriented Programming (FPOP) is an emerging paradigm designed to streamline the implementation of problems involving self-referential computations. These include graph algorithms, static analysis, parsing, and distributed computing-domains that traditionally require complex and tricky-to-implement work-queue algorithms. Existing programming paradigms lack direct support for these inherently fixed-point computations, leading to inefficient and error-prone implementations. This white paper explores the potential of the FPOP paradigm, which offers a high-level abstraction that enables concise and expressive problem formulations. By leveraging structured inference rules and user-directed optimizations, FPOP allows developers to write declarative specifications while the compiler ensures efficient execution. It not only reduces implementation complexity for programmers but also enhances adaptability, making it easier for programmers to explore alternative solutions and optimizations without modifying the core logic of their program. We demonstrate how FPOP simplifies algorithm implementation, improves maintainability, and enables rapid prototyping by allowing problems to be clearly and concisely expressed. For example, the graph distance problem can be expressed in only two executable lines of code with FPOP, while it takes an order of magnitude more code in other paradigms. By bridging the gap between theoretical fixed-point formulations and practical implementations, we aim to foster further research and adoption of this paradigm.

Fraser Tweedale
@hackuador@functional.cafe

Exciting lineup for Brisbane Functional Programming Group August 12 meetup: Explicit Substitutions pt2 (Donovan Crichton) + Overview of flake-parts and -flake (Jack Kelly). lu.ma/r002tby5

lu.ma

BFPG Meetup - August 2025 - Explicit Substitutions pt2 + Nix Flakes · Luma

Agenda 18:00: Welcome and setup Presentation #1: Explicit Substitutions Part 2 - Donovan Crichton Presentation #2: Overview of flake-parts and haskell-flake -…

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared July 29, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared July 29, 2025

The readings shared in Bluesky on 29 July 2025 are Algorithmic conversion with surjective pairing: A syntactic and untyped approach. ~ Yiyun Liu, Stephanie Weirich. #FormalVerification #ProofAssistan

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared July 28, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared July 28, 2025

The readings shared in Bluesky on 28 July 2025 are Gödel's first incompleteness theorem (in Lean4). #FormalVerification #ProofAssistant #LeanProver #Logic #Math Formalized formal logic (in Lean4). #F

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared July 27, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared July 27, 2025

The readings shared in Bluesky on 27 July 2025 are Formally verified suffix array construction (in Isabelle/HOL). ~ Louis Cheung, Alistair Moffat, Christine Rizkallah. #FormalVerification #ProofAssis

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Formally verified suffix array construction (in Isabelle/HOL). ~ Louis Cheung, Alistair Moffat, Christine Rizkallah. link.springer.com/article/10.1

link.springer.com

Formally Verified Suffix Array Construction - Journal of Automated Reasoning

Suffix arrays are a data structure with numerous real-world applications. They are extensively used in text retrieval and data compression applications, including query suggestion mechanisms in web search, and in bioinformatics tools for DNA sequencing and matching. This wide applicability means that algorithms for constructing suffix arrays are of great practical importance. The SA-IS algorithm is an efficient but conceptually complex suffix array construction technique, and implementing it requires a deep understanding of its underlying theory. As a critical step towards developing a provably correct and efficient implementation, we have developed the SA-IS algorithm in Isabelle/HOL and formally verified that it is equivalent to a mathematical functional specification of suffix arrays, a task that required verifying a wide range of underlying properties of strings and suffixes. We also used Isabelle’s code extraction facilities to extract an executable Haskell implementation of SA-IS, which albeit is inefficient due to using lists and natural numbers rather than arrays and machine words, demonstrates that our verified HOL implementation of SA-IS can be refined to an executable implementation in its current form.

kakkun61.com
@kakkun61@pawoo.net · Reply to kakkun61.com

📣『俺々言語にだって型推論が欲しい！』も印刷版が買えるようになりました！ kakkun61.booth.pm/items/131748

kakkun61.booth.pm

俺々言語にだって型推論が欲しい！ - 趣味はデバッグ…… - BOOTH

型推論器を自作することでそのしくみを理解しようという書籍です。 シンプルな言語を定義し、それに対して型推論する方法を紹介しています。 前半3分の2は理論の説明で、後半3分の1は実装の解説です。 実装には Haskell を用いていますが、理論の説明を読んで各々好きな言語で実装すればよいです。 印刷版には電子版が付属します。

kakkun61.com
@kakkun61@pawoo.net · Reply to kakkun61.com

📣『手続き Haskell』も印刷版が買えるようになりました！ kakkun61.booth.pm/items/829369

kakkun61.booth.pm

手続き Haskell - 趣味はデバッグ…… - BOOTH

本書は Haskell における手続きプログラミングについて解説した書籍です。 手続きプログラマーにこそ読んでほしい Haskell の書籍です。 本書の目的には2つあります。 • 1つは、Haskell というと実際以上に関数プログラミングであるという印象の人が多いのでその解消をする。 • もう1つは、Haskell が読めるけど書けないという人への手助けとする。これは関数プログラミング的アプローチを一旦やめることで、Haskell が書けるとすることです。 また、手続きプログラミングから関数プログラミングへの書き換えについても触れています。 印刷版には電子版が付属します。

kakkun61.com
@kakkun61@pawoo.net

あの『モナドドリル』が、ウェブでも印刷版を買えるようになりました！　注文されたら @kakkun61 がちまちま梱包して郵送に出します！　他の同人誌も1週間をめどに追加予定です kakkun61.booth.pm/items/722235

kakkun61.booth.pm

モナドドリル - 趣味はデバッグ…… - BOOTH

モナドの読解力と利用力がつく！ 印刷版には PDF が付属します。

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Type-level programming for safer resource management. ~ Fraser Tweedale. frasertweedale.github.io/blog-

frasertweedale.github.io

Type-level programming for safer resource management

I find type-level naturals useful for enforcing proper usage of APIs or protocols that involve transactions, locking, memory (de)allocation, and similar concerns. In this post I demonstrate the main idea and discuss some of the shortcomings when using this technique with Haskell.

Philipp :emacs: :nixos:
@pmidden@fosstodon.org

pretty print structured data, recommendations? I currently recurse over my structure, tracking indentation level. Works, but is definitely a little clumsy.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared July 19, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared July 18, 2025

The readings shared in Bluesky on 18 July 2025 are Formalization of derived categories in Lean/Mathlib. ~ Joël Riou. #ITP #LeanProver #Math A formalised approach to the composition of processes over

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared July 18, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared July 18, 2025

The readings shared in Bluesky on 18 July 2025 are Teaching software specification (Experience report). ~ Cameron Moy, Daniel Patterson. #CompSci #Teaching #ITP #LeanProver #ACL2 CSLib: An open-sourc

DiazCarrete
@DiazCarrete@hachyderm.io

Suffering from the scourge of insomnia? Want to fall asleep to the sounds of a Haskell application being assembled component by component?

If so, you're in luck. In this 1-hour video I give a demo of how to use the "cauldron" library to wire all the components of a Haskell application at the composition root.

youtube.com/watch?v=9ZJLK0iM-2

youtube.com

Dependency injection in Haskell: wiring you application using "cauldron"

This is an example of how to use the "cauldron" library for wiring a small Haskell application. The application is structured as a bunch of records-of-functi...

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared July 12, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared July 12, 2025

The readings shared in Bluesky on 12 July 2025 are A formalization of divided powers in Lean. ~ Antoine Chambert-Loir, María Inés de Frutos-Fernández. #ITP #LeanProver #Math Completeness of the decre

HaskellOrg
@haskell@fosstodon.org

To those who could not attend 2025, we salute you!

The videos of this year's talks are now available discourse.haskell.org/t/zuriha

discourse.haskell.org

ZuriHac 2025 Videos Online

Hi Everyone It was great to see you at ZuriHac 2025. In case you couldn’t attend, or would like to relive the magic, the recordings from the event are now online at: ZuriHac 2025 Playlist – Talks, Panels & Projects from the Haskell Community In this playlist, you’ll find talks on: 🎓 Education, Pedagogy and Community Zoe Kooyman on freedom-preserving software, ethics, and empowering developers through appropriate software licensing Richard Southwell on category theory Tom Ell...

HaskellOrg
@haskell@fosstodon.org

To those who could not attend 2025, we salute you!

The videos of this year's talks are now available discourse.haskell.org/t/zuriha

discourse.haskell.org

ZuriHac 2025 Videos Online

Hi Everyone It was great to see you at ZuriHac 2025. In case you couldn’t attend, or would like to relive the magic, the recordings from the event are now online at: ZuriHac 2025 Playlist – Talks, Panels & Projects from the Haskell Community In this playlist, you’ll find talks on: 🎓 Education, Pedagogy and Community Zoe Kooyman on freedom-preserving software, ethics, and empowering developers through appropriate software licensing Richard Southwell on category theory Tom Ell...

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared July 9, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared July 9, 2025

The readings shared in Bluesky on 9 July 2025 are Formalising the local compactness of the adele ring. ~ Salvatore Mercuri. #ITP #LeanProver #Math Doing Lean dirty: Lean as a Jupyter notebook replace

HaskellOrg
@haskell@fosstodon.org

To those who could not attend 2025, we salute you!

The videos of this year's talks are now available discourse.haskell.org/t/zuriha

discourse.haskell.org

ZuriHac 2025 Videos Online

Hi Everyone It was great to see you at ZuriHac 2025. In case you couldn’t attend, or would like to relive the magic, the recordings from the event are now online at: ZuriHac 2025 Playlist – Talks, Panels & Projects from the Haskell Community In this playlist, you’ll find talks on: 🎓 Education, Pedagogy and Community Zoe Kooyman on freedom-preserving software, ethics, and empowering developers through appropriate software licensing Richard Southwell on category theory Tom Ell...

Andres Löh
@kosmikus@functional.cafe

Today, Wednesday, 2025-07-09, at 1830 UTC, there's going to be a new episode of the . Edsko and I will show how to develop a small but useful Haskell CLI application completely from scratch.

youtube.com/watch?v=5W0ZUY_l1d

youtube.com

Developing an application from scratch (Haskell Unfolder #46)

In this episode targeted at beginners, we show the end-to-end application development process, starting from an empty directory. We'll consider package confi...

HaskellOrg
@haskell@fosstodon.org

Better infrastructure, fewer surprises. We’re raising $6K for a dedicated ARM server to support ’s infrastructure - CI, backups, and more. Let’s build infra you can reliably pattern match on. Every contribution helps!

Donate: donorbox.org/infrastructure-in
Read more: discourse.haskell.org/t/infras

discourse.haskell.org

Infrastructure Independence!

Better Equipped Infrastructure We’re hosting a fundraiser! For the next four weeks, any donations made via Infrastructure Independence | Haskell.org, Inc (Powered by Donorbox), will be used solely for Haskell infrastructure and no other HF related initiatives. Historically, the Haskell community has relied on a mix of cloud providers and self-hosted servers for our core infrastructure (Hackage, Stackage, GHC, CI, etc.). More recently the Haskell Infrastructure team has completed a migration of ...

The Haskell Foundation
@haskell_foundation@mastodon.social

Better infrastructure, fewer surprises. We’re raising $6K for a dedicated ARM server to support ’s infrastructure (CI, backups, etc). Let’s build infra you can rely on! Every contribution helps!

Donate: donorbox.org/infrastructure-in
Read more: discourse.haskell.org/t/infras

discourse.haskell.org

Infrastructure Independence!

Better Equipped Infrastructure We’re hosting a fundraiser! For the next four weeks, any donations made via Infrastructure Independence | Haskell.org, Inc (Powered by Donorbox), will be used solely for Haskell infrastructure and no other HF related initiatives. Historically, the Haskell community has relied on a mix of cloud providers and self-hosted servers for our core infrastructure (Hackage, Stackage, GHC, CI, etc.). More recently the Haskell Infrastructure team has completed a migration of ...

The Haskell Foundation
@haskell_foundation@mastodon.social

Better infrastructure, fewer surprises. We’re raising $6K for a dedicated ARM server to support ’s infrastructure (CI, backups, etc). Let’s build infra you can rely on! Every contribution helps!

Donate: donorbox.org/infrastructure-in
Read more: discourse.haskell.org/t/infras

discourse.haskell.org

Infrastructure Independence!

Better Equipped Infrastructure We’re hosting a fundraiser! For the next four weeks, any donations made via Infrastructure Independence | Haskell.org, Inc (Powered by Donorbox), will be used solely for Haskell infrastructure and no other HF related initiatives. Historically, the Haskell community has relied on a mix of cloud providers and self-hosted servers for our core infrastructure (Hackage, Stackage, GHC, CI, etc.). More recently the Haskell Infrastructure team has completed a migration of ...

HaskellOrg
@haskell@fosstodon.org

Better infrastructure, fewer surprises. We’re raising $6K for a dedicated ARM server to support ’s infrastructure - CI, backups, and more. Let’s build infra you can reliably pattern match on. Every contribution helps!

Donate: donorbox.org/infrastructure-in
Read more: discourse.haskell.org/t/infras

discourse.haskell.org

Infrastructure Independence!

Better Equipped Infrastructure We’re hosting a fundraiser! For the next four weeks, any donations made via Infrastructure Independence | Haskell.org, Inc (Powered by Donorbox), will be used solely for Haskell infrastructure and no other HF related initiatives. Historically, the Haskell community has relied on a mix of cloud providers and self-hosted servers for our core infrastructure (Hackage, Stackage, GHC, CI, etc.). More recently the Haskell Infrastructure team has completed a migration of ...

Teixi
@teixi@mastodon.social · Reply to Marcel Fröhlich

@FrohlichMarcel

Oh là là just dropped:
2.5 hour "Introduction To Category Theory"
by Richard Southwell
youtu.be/H32kyA4BMz4

HT @zurihac

youtube.com

Category Theory: Introducing The Perfect Language (Talk At ZuriHac 2025)

This is a recording of the 2.5 hour "Introduction To Category Theory" talk I was invited to give at ZuriHac 2025 Haskell conference. In the talk I start fro...

Teixi
@teixi@mastodon.social · Reply to Marcel Fröhlich

@FrohlichMarcel

Oh là là just dropped:
2.5 hour "Introduction To Category Theory"
by Richard Southwell
youtu.be/H32kyA4BMz4

HT @zurihac

youtube.com

Category Theory: Introducing The Perfect Language (Talk At ZuriHac 2025)

This is a recording of the 2.5 hour "Introduction To Category Theory" talk I was invited to give at ZuriHac 2025 Haskell conference. In the talk I start fro...

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared July 5, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared July 5, 2025

The readings shared in Bluesky on 5 July 2025 are The filter game (in Lean 4). ~ Kevin Buzzard. #ITP #LeanProver #Math Formal verification of quantum stabiliser codes by stabiliser formalism. ~ Qiuyi

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

A diagrammatic calculus for a functional model of natural language semantics. ~ Matthieu Pierre Boyer. arxiv.org/abs/2507.00782v1

arxiv.org

A Diagrammatic Calculus for a Functional Model of Natural Language Semantics

In this paper, we study a functional programming approach to natural language semantics, allowing us to increase the expressivity of a more traditional denotation style. We will formalize a category based type and effect system, and construct a diagrammatic calculus to model parsing and handling of effects, and use it to efficiently compute the denotations for sentences.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared July 4, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared July 4, 2025

The readings shared in Bluesky on 4 July 2025 are LeanConjecturer: Automatic generation of mathematical conjectures for theorem proving. ~ Naoto Onda et als. #ITP #LeanProver #Math #LLMs An introduct

Momo 🏳️‍⚧️:nonbinary_flag:
@momo@woof.tech

mreeow! Hi! My name is Momo! I'm a transfemme, and she/they is my preferred pronouns.

I code as a hobby in and . I also use as my main daily driver since last year. :blobfoxcomputer: :nkoLove:

I enjoy creating casual game mods in my free time, including Stardew Valley, , and various other games. :apartyblobcat:

I also love playing Cataclysm: Bright Nights () and Valley. Sometimes, , and too, because why not? I like the look and feel of these games. :blobcat3c:

During the weekends, I try to finish reading a fantasy book or two, if I'm feeling reaaaaally cozy :blobcattea: :blobcatmorningtea:

I will be posting about techy stuff that I encounter (mainly and ), share my gaming experiences, and rant about random things, ranging from politics to personal life.

And I like to sip a cup of coffee while watching camping videos, too, for some reason. :blabfox:

Feel free to follow me if you want to hear more of my blabbing! :blobcat_mlem: :blobcat_nwn:

PS: I will put distressing or NSFW posts behind CW. :blobcatpeek:

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared June 30, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared June 30, 2025

The readings shared in Bluesky on 30 June 2025 are Teaching children thinking. ~ Seymour A. Papert (1971). #CompSci #Teaching Curso "Lógica matemática y fundamentos (2016-17)". #Lógica #Haskell #Prog

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared June 29, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared June 29, 2025

The readings shared in Bluesky on 29 June 2025 are Constructing the Lie algebra of smooth vector fields on a Lie group in Isabelle/HOL. ~ Richard Schmoetten, Jacques D. Fleuriot. #ITP #IsabelleHOL #M

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared June 28, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared June 28, 2025

The readings shared in Bluesky on 28 June 2025 are IsaBIL: A framework for verifying (in)correctness of binaries in Isabelle/HOL. ~ Matt Griffin, Brijesh Dongol, Azalea Raad. #ITP #IsabelleHOL Multip

Andres Löh
@kosmikus@functional.cafe

On Wednesday, 2025-06-25, at 1830 UTC, there will be a new episode of the . This time, Edsko and I will discuss the current situation of records in Haskell.

youtube.com/watch?v=9hrDm7xDpi

youtube.com

Haskell records in 2025 (Haskell Unfolder #45)

Haskell records as originally designed have had a reputation of being somewhat weird or, at worst, useless. A lot of features and modifications have been pro...

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared June 23, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared June 23, 2025

The readings shared in Bluesky on 23 June 2025 are Formalising differential geometry and topology in Lean: Differential forms and the Whitney–Graustein theorem. ~ Sam J. L. Lindauer. #ITP #LeanProver

DiazCarrete
@DiazCarrete@hachyderm.io

Enough. The reign of terror of the bare type synonyms in Network.Wai must come to an end.

Application hackage.haskell.org/package/wa
Middleware hackage.haskell.org/package/wa

Haskell code that gives newtype wrappers to the "Application" and "Middleware" type synonyms from module Network.Wai. Also, a DerivingVia-derived Monoid instance for the Middleware newtype that composes left-to-right.
ALT text

Haskell code that gives newtype wrappers to the "Application" and "Middleware" type synonyms from module Network.Wai. Also, a DerivingVia-derived Monoid instance for the Middleware newtype that composes left-to-right.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared June 21, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared June 21, 2025

The readings shared in Bluesky on 21 June 2025 are Theorem proving in Lean 4. ~ Jeremy Avigad, Leonardo de Moura, Soonho Kong, Sebastian Ullrich et als. #ITP #LeanProver Certifying projected knowledg

DiazCarrete
@DiazCarrete@hachyderm.io

Published on Hackage a new version of my "cauldron" dependency injection library, with some tweaks and a smaller dependency footprint (I vendored the parts I used from Andrey Mokhov's "algebraic-graphs" library, and exposed them as a sublibrary):
hackage.haskell.org/package/ca

Example of use github.com/danidiaz/comments-p compared to manual wiring github.com/danidiaz/comments-p

github.com

comments-project/comments/app/Main.hs at f16fb09c90a851054e8e97a82b38a563ff0eea18 · danidiaz/comments-project

Contribute to danidiaz/comments-project development by creating an account on GitHub.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Freer arrows and why you need them in Haskell. ~ Grant VanDomelen, Gan Shen, Lindsey Kuper, Yao Li. arxiv.org/abs/2506.12212v1

arxiv.org

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.

Philipp :emacs: :nixos:
@pmidden@fosstodon.org

I've surprised myself how fun it is to write this pure parser. It's, in a way, gruesome, fiddling with raw bytes, guessing some details, getting new files with features still unsupported, and I have no clue how exciting it will be to implement all the common filters. But the language is delightful and I'm making constant glacial progress. That accounts for a lot I suppose...

DiazCarrete
@DiazCarrete@hachyderm.io

"I believe that effect libraries are good for actual effects (IO, State, Reader, Non-determinism, etc...) but not for creating software components"
reddit.com/r/haskell/comments/

Do we need effects to get abstraction? (2019) medium.com/barely-functional/d

medium.com

Do we need effects to get abstraction?

Sandy Maguire gave an excellent talk on his latest library: polysemy. I highly encourage you to watch it because Sandy also presents other…

Andrzej Wąsowski ☑️ 🟥
@AndrzejWasowski@social.itu.dk

I am using one tool implemented in Haskell. Cost: my updates about 100 packages every 2 days on average. Seriously? I am starting to think that even though I am a programmer, programming in Haskell would not be for me - and not for the ferocious purity and laziness, but for the stability of the environment!

Disclaimer: I know nothing about the Haskell ecosystem. It may well be that these updates are just as innocuous as they are irritating.

Abhinav 🧭
@abnv@fantastic.earth

Yay! My PR¹ for building static executables for projects with has been merged in my favourite Nix-for-haskell framework Nixkell.

¹ github.com/pwm/nixkell/pull/50

github.com

Add support for building statically-linked executable by abhin4v · Pull Request #50 · pwm/nixkell

This PR adds support for easily building statically-linked executable using Nixkell and Nix. Majorly, it: adds an overlays-static.nix file that configures GHC and Haskell packages for building sta...

Philipp :emacs: :nixos:
@pmidden@fosstodon.org · Reply to Brent Yorgey

@byorgey And here's me, about to give a tutorial and on the way to work, thinking that I should definitely mention that "IO" is different than "Maybe", "List", ... because in what way would "IO String" be a container"?

Good to have come to the same conclusion.

HaskellOrg
@haskell@fosstodon.org

Picking up is not a matter of "If" but of "When".

When your head overflows with UML diagrams instead of expressive yet concise types?

When your systems belch runtime exceptions like a Weezing?

When shared mutable state prevents you from understanding what the hell is happening?

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared June 15, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared June 15, 2025

The readings shared in Bluesky on 15 June 2025 are BiCoq: Bigraphs formalisation with Coq. ~ Cécile Marcon et als. #ITP #CoqProver #Rocq #Math Introduction to competitive programming in Haskell. ~ Br

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared June 14, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared June 14, 2025

The readings shared in Bluesky on 14 June 2025 are Formalizing information theory in Lean 4: divergences, hypothesis testing and the data processing inequality. ~ Lorenzo Luccioli. #ITP #LeanProver #

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared June 12, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared June 12, 2025

The readings shared in Bluesky on 12 June 2025 are Formalizing the divided power envelope in Lean. ~ María Inés de Frutos Fernández. #ITP #LeanProver #Math Lean meta-theory: The proofs behind the pro

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared June 9, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared June 9, 2025

The readings shared in Bluesky on 9 June 2025 are Formalizing invisible mathematics: case studies from higher category theory. ~ Emily Riehl. #ITP #LeanProver #Math #CategoryTheory Sequencelib: A pla

Boyd Stephen Smith Jr.
@BoydStephenSmithJr@hachyderm.io

Just put in another application via so I also wanted to try to get again.

I've been a programmer since 1985 (as a child), I've been an IT professional since 1995 (pulling wires and swapping cards and configuring MS Windows). I graduated from University of Arkansas Fayetteville with a BS in CS in December of 2003. A full resume is available.

I currently require a 100% remote position. I cannot relocate from Cove, .

I prefer something where I can be a high-performing individual contributor: reading, writing and improving source text the majority of my day, with some time spent knowledge-sharing with other developers -- learning and teaching. I'd like to work with , , or as the primary source language, but I can be productive in almost any language (no PHP, please; I promised myself never again).

I would prefer W-2 employment with a base salary of at least 130k USD/yr, plus some sort of retirement offering (401k or similar) and healthcare benefits (HDCP + HSA or similar).

(Boosts appreciated.)

Boyd Stephen Smith Jr.
@BoydStephenSmithJr@hachyderm.io

Just put in another application via so I also wanted to try to get again.

I've been a programmer since 1985 (as a child), I've been an IT professional since 1995 (pulling wires and swapping cards and configuring MS Windows). I graduated from University of Arkansas Fayetteville with a BS in CS in December of 2003. A full resume is available.

I currently require a 100% remote position. I cannot relocate from Cove, .

I prefer something where I can be a high-performing individual contributor: reading, writing and improving source text the majority of my day, with some time spent knowledge-sharing with other developers -- learning and teaching. I'd like to work with , , or as the primary source language, but I can be productive in almost any language (no PHP, please; I promised myself never again).

I would prefer W-2 employment with a base salary of at least 130k USD/yr, plus some sort of retirement offering (401k or similar) and healthcare benefits (HDCP + HSA or similar).

(Boosts appreciated.)

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared June 8, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared June 8, 2025

The readings shared in Bluesky on 8 June 2025 are The illusion of thinking: Understanding the strengths and limitations of reasoning models via the lens of problem complexity. ~ Parshin Shojaee et al

Haskell Weekly
@haskell_discussions@mastodon.social

Proposal: add Data.List.NonEmpty.mapMaybe :: (a -> Maybe b) -> NonEmpty a -> [b]

github.com/haskell/core-librar

Discussions: discu.eu/q/https://github.com/

discu.eu

Add Data.List.NonEmpty.mapMaybe :: (a -> Maybe b) -> NonEmpty a -> [b] · Issue #337 · haskell/core-libraries-committee · GitHub - discu.eu

Discussions and related articles for «Add Data.List.NonEmpty.mapMaybe :: (a -> Maybe b) -> NonEmpty a -> [b] · Issue #337 · haskell/core-libraries-committee · GitHub»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Big steps in higher-order mathematical operational semantics. ~ Sergey Goncharov, Pouya Partow, Stelios Tsampas. arxiv.org/abs/2506.01076

arxiv.org

Big Steps in Higher-Order Mathematical Operational Semantics

Small-step and big-step operational semantics are two fundamental styles of structural operational semantics (SOS), extensively used in practice. The former one is more fine-grained and is usually regarded as primitive, as it only defines a one-step reduction relation between a given program and its direct descendant under an ambient evaluation strategy. The latter one implements, in a self-contained manner, such a strategy directly by relating a program to the net result of the evaluation process. The agreement between these two styles of semantics is one of the key pillars in operational reasoning on programs; however, such agreement is typically proven from scratch every time on a case-by-case basis. A general, abstract mathematical argument behind this agreement is up till now missing. We cope with this issue within the framework of higher-order mathematical operational semantics by providing an abstract categorical notion of big-step SOS, complementing the existing notion of abstract higher-order GSOS. Moreover, we introduce a general construction for deriving the former from the latter, and prove an abstract equivalence result between the two.

voyd
@voyd@nullptr.rehab

"Look, I don't think there's anything wrong with programming in or , but you should probably switch to when you hit like 3 or 4 months of experience

Philipp :emacs: :nixos:
@pmidden@fosstodon.org

Am I correct in assuming that in , parsing a huge file with attoparsec is a bad idea, because the memory footprint will be equally huge?

Is there an alternative?

Haskell Weekly
@haskell_discussions@mastodon.social

What Works (and Doesn't) Selling Formal Methods

galois.com/articles/what-works

Discussions: discu.eu/q/https://www.galois.

discu.eu

Galois - What Works (and Doesn't) Selling Formal Methods - discu.eu

Discussions and related articles for «Galois - What Works (and Doesn't) Selling Formal Methods»

Haskell Weekly
@haskell_discussions@mastodon.social

List Unfolding - `unfold` as the Computational Dual of `fold`, and how `unfold` relates to `iterate`

fpilluminated.org/deck/263

Discussions: discu.eu/q/https://fpilluminat

discu.eu

List Unfolding - 'unfold' as the Computational Dual of 'fold', and how 'unfold' relates to 'iterate' - discu.eu

Discussions and related articles for «List Unfolding - 'unfold' as the Computational Dual of 'fold', and how 'unfold' relates to 'iterate'»

Haskell Weekly
@haskell_discussions@mastodon.social

Zero-Cost 'Tagless Final' in Rust with GADT-style Enums

inferara.com/en/blog/rust-tagl

Discussions: discu.eu/q/https://www.inferar

discu.eu

Zero-Cost 'Tagless Final' in Rust with GADT-style Enums | Inferara - discu.eu

Discussions and related articles for «Zero-Cost 'Tagless Final' in Rust with GADT-style Enums | Inferara»

Haskell Weekly
@haskell_discussions@mastodon.social

[ANN] haskell-google-genai-client: API Client for Google Gemini

hackage.haskell.org/package/ha

Discussions: discu.eu/q/https://hackage.has

discu.eu

haskell-google-genai-client: Auto-generated Gemini API Client for Haskell - discu.eu

Discussions and related articles for «haskell-google-genai-client: Auto-generated Gemini API Client for Haskell»

claude
@mathr@post.lurk.org · Reply to Syntə

today (thanks to augustss fixing some MicroHs bugs) I managed to get tidal-core working in MicroHs!

this is just the pattern language, not including live scheduler, OSC message sending, etc.

The next step is to combine this toot with previous toot and have a Tidal/Haskell thing running inside a web browser. But there's a lot of rest of owl before that will do anything useful.

I pushed my branch to Microsoft Github for ease of review:
github.com/claudeha/Tidal/tree

@synte

dark mode terminal showing someone who doesn't know tidal's module structure trying to run a pattern. the cool part is that it's using MicroHs instead of GHC.
ALT text

dark mode terminal showing someone who doesn't know tidal's module structure trying to run a pattern. the cool part is that it's using MicroHs instead of GHC.

claude
@mathr@post.lurk.org · Reply to Syntə

today (thanks to augustss fixing some MicroHs bugs) I managed to get tidal-core working in MicroHs!

this is just the pattern language, not including live scheduler, OSC message sending, etc.

The next step is to combine this toot with previous toot and have a Tidal/Haskell thing running inside a web browser. But there's a lot of rest of owl before that will do anything useful.

I pushed my branch to Microsoft Github for ease of review:
github.com/claudeha/Tidal/tree

@synte

dark mode terminal showing someone who doesn't know tidal's module structure trying to run a pattern. the cool part is that it's using MicroHs instead of GHC.
ALT text

dark mode terminal showing someone who doesn't know tidal's module structure trying to run a pattern. the cool part is that it's using MicroHs instead of GHC.

claude
@mathr@post.lurk.org

seems I somehow got interpreter compiled and working in a browser using

used a require.js I found online (from Tarp pixelsvsbytes.com/2013/02/js-r ) and slighly patched for my use case / url layout, and some minimal folder (npm install --save path) with custom symlinks inside to choose the browser js.

the HTML from Emscripten is patched lightly to add the require script and a couple of require() calls. the standard library is included with preload file; the total size of the served folder is about 3.5MB.

the usability is terrible (have to enter input in a modal form with no history or completion etc, output goes to browser console) but it's a start!

desktop screenshot of firefox open at localhost : 8080 / mhs.html there is a large Input: modal dialog, behind which is a default Emscripten HTML page. mhs welcome banner is visible in the emscripten text area, but subsequent input and output is only echoed in the browser developer tools console, visible at the bottom, where you can see "hello world" and factorials from 1 to 10.
ALT text

desktop screenshot of firefox open at localhost : 8080 / mhs.html there is a large Input: modal dialog, behind which is a default Emscripten HTML page. mhs welcome banner is visible in the emscripten text area, but subsequent input and output is only echoed in the browser developer tools console, visible at the bottom, where you can see "hello world" and factorials from 1 to 10.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared May 31, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared May 31, 2025

The readings shared in Bluesky on 31 May 2025 are Formalizing a classification theorem for low-dimensional solvable Lie algebras in Lean. ~ Viviana del Barco et als. #ITP #LeanProver #Math Lean4Lean:

maralorn
@maralorn@chaos.social

I will be teaching the track at 🇨🇭 ⛰️

zfoh.ch/zurihac2025/

Looking forward to showing you all the best(TM) way to setup packages with Nix 😎 Maybe we can even upstream some Haskell packages to ? 😆

I jumped in a bit on short notice and am still collecting ideas. So let me know what you would like to learn!

zfoh.ch

ZuriHac 2025

ZuriHac is a free annual Haskell event brought to you by «Zürich Friends of Haskell»

Abhinav 🧭
@abnv@fantastic.earth

It is a good day to unleash the agent of chaos.

Screenshot of the documentation of the Haskell function accursedUnutterablePerformIO: accursedUnutterablePerformIO :: IO a -> a This "function" has a superficial similarity to unsafePerformIO but it is in fact a malevolent agent of chaos. It unpicks the seams of reality (and the IO monad) so that the normal rules no longer apply. It lulls you into thinking it is reasonable, but when you are not looking it stabs you in the back and aliases all of your mutable buffers. The carcass of many a seasoned Haskell programmer lie strewn at its feet. Witness the trail of destruction: https://github.com/haskell/bytestring/commit/71c4b438c675aa360c79d79acc9a491e7bbc26e7 https://github.com/haskell/bytestring/commit/210c656390ae617d9ee3b8bcff5c88dd17cef8da https://github.com/haskell/aeson/commit/720b857e2e0acf2edc4f5512f2b217a89449a89d https://ghc.haskell.org/trac/ghc/ticket/3486 https://ghc.haskell.org/trac/ghc/ticket/3487 https://ghc.haskell.org/trac/ghc/ticket/7270 https://gitlab.haskell.org/ghc/ghc/-/issues/22204 Do not talk about "safe"! You do not know what is safe! Yield not to its blasphemous call! Flee traveller! Flee or you will be corrupted and devoured!
ALT text

Screenshot of the documentation of the Haskell function accursedUnutterablePerformIO: accursedUnutterablePerformIO :: IO a -> a This "function" has a superficial similarity to unsafePerformIO but it is in fact a malevolent agent of chaos. It unpicks the seams of reality (and the IO monad) so that the normal rules no longer apply. It lulls you into thinking it is reasonable, but when you are not looking it stabs you in the back and aliases all of your mutable buffers. The carcass of many a seasoned Haskell programmer lie strewn at its feet. Witness the trail of destruction: https://github.com/haskell/bytestring/commit/71c4b438c675aa360c79d79acc9a491e7bbc26e7 https://github.com/haskell/bytestring/commit/210c656390ae617d9ee3b8bcff5c88dd17cef8da https://github.com/haskell/aeson/commit/720b857e2e0acf2edc4f5512f2b217a89449a89d https://ghc.haskell.org/trac/ghc/ticket/3486 https://ghc.haskell.org/trac/ghc/ticket/3487 https://ghc.haskell.org/trac/ghc/ticket/7270 https://gitlab.haskell.org/ghc/ghc/-/issues/22204 Do not talk about "safe"! You do not know what is safe! Yield not to its blasphemous call! Flee traveller! Flee or you will be corrupted and devoured!

maralorn
@maralorn@chaos.social

I will be teaching the track at 🇨🇭 ⛰️

zfoh.ch/zurihac2025/

Looking forward to showing you all the best(TM) way to setup packages with Nix 😎 Maybe we can even upstream some Haskell packages to ? 😆

I jumped in a bit on short notice and am still collecting ideas. So let me know what you would like to learn!

zfoh.ch

ZuriHac 2025

ZuriHac is a free annual Haskell event brought to you by «Zürich Friends of Haskell»

Haskell Weekly
@haskell_discussions@mastodon.social

Violating memory safety with Haskell's value restriction

welltypedwit.ch/posts/value-re

Discussions: discu.eu/q/https://welltypedwi

discu.eu

Violating memory safety with Haskell's value restriction - discu.eu

Discussions and related articles for «Violating memory safety with Haskell's value restriction»

Abhinav 🧭
@abnv@fantastic.earth

is dying so it's appropriate to talk about the minimal service I wrote for myself: LinkFodder.

You can save links via an API, or a form, or a Telegram bot, and you get an HTML page (shown below) and an Atom . That’s it.

Supports multiple users, written in , deployable as a single binary (or a Docker image) behind the reverse-proxy server of your choice in your setup.

It doesn't even need a database to run; it simply rewrites the HTML and Atom files when you save a new link.

Screenshot of Linkfodder page for me. Shows number of links saved, time for last update, and two latest links. Also shows a form to save URLs, and a link to a feed of links.
ALT text

Screenshot of Linkfodder page for me. Shows number of links saved, time for last update, and two latest links. Also shows a form to save URLs, and a link to a feed of links.

Haskell Weekly
@haskell_discussions@mastodon.social

Artiflakery, an easy way to distribute static Nix flake artifacts

luj.fr/blog/artiflakery-webser

Discussions: discu.eu/q/https://luj.fr/blog

discu.eu

Artiflakery, an easy way to distribute static Nix flake artifacts - discu.eu

Discussions and related articles for «Artiflakery, an easy way to distribute static Nix flake artifacts»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared May 20, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared May 20, 2025

The readings shared in Bluesky on 20 May 2025 are Formalising the Bruhat-Tits tree. ~ Judith Ludwig, Christian Merten. #ITP #LeanProver Ordinal exponentiation in homotopy type theory. ~ Tom de Jong,

Haskell Weekly
@haskell_discussions@mastodon.social

Tipos Abstractos y Polimorfismo en Programación Funcional

emanuelpeg.blogspot.com/2025/0

Discussions: discu.eu/q/https://emanuelpeg.

discu.eu

Emanuel Goette, alias Crespo: Tipos Abstractos y Polimorfismo en Programación Funcional - discu.eu

Discussions and related articles for «Emanuel Goette, alias Crespo: Tipos Abstractos y Polimorfismo en Programación Funcional»

DiazCarrete
@DiazCarrete@hachyderm.io

Violating memory safety with Haskell's value restriction welltypedwit.ch/posts/value-re
discourse.haskell.org/t/violat

discourse.haskell.org

Violating memory safety with Haskell's value restriction

Thanks! Very clear, well-written and interesting article. Does that mean that this definition from linear-base is unsafe? I attempted to use your same trick to derive something unsafe, but I couldn’t get it to work. It don’t know whether it doesn’t work because of some issue with linear lets, or Ur, or something else, and whether the “issue” is intended (and is a theoretical means of preventing unsafety) or it’s unintended and can be worked around. ▶ Not working linear example

das-g
@das_g@chaos.social · Reply to Ramin Honary

@ramin_hal9001 I've got a question about that:
discourse.haskell.org/t/is-the

discourse.haskell.org

Is the IO type built-in?

When I learned Haskell, I’ve learned that the type constructor IO is “built-in” to the language, i.e., has to be implemented in the compiler and/or runtime themselves, rather than (like — say — Maybe (docs, source code)) in a library that ships with the compiler (and may be imported by default) but is otherwise treated just like my own Haskell code. Though, is that actually true? The documentation for Prelude.IO doesn’t mention its definition, but links to source code (the same that the docume...

das-g
@das_g@chaos.social · Reply to Ramin Honary

@ramin_hal9001 I've got a question about that:
discourse.haskell.org/t/is-the

discourse.haskell.org

Is the IO type built-in?

When I learned Haskell, I’ve learned that the type constructor IO is “built-in” to the language, i.e., has to be implemented in the compiler and/or runtime themselves, rather than (like — say — Maybe (docs, source code)) in a library that ships with the compiler (and may be imported by default) but is otherwise treated just like my own Haskell code. Though, is that actually true? The documentation for Prelude.IO doesn’t mention its definition, but links to source code (the same that the docume...

Haskell Weekly
@haskell_discussions@mastodon.social

[ANN] GHCup 0.1.50.2 release (LD breakage)

discourse.haskell.org/t/ann-gh

Discussions: discu.eu/q/https://discourse.h

discu.eu

[ANN] GHCup 0.1.50.2 release (LD breakage) - Announcements - Haskell Community - discu.eu

Discussions and related articles for «[ANN] GHCup 0.1.50.2 release (LD breakage) - Announcements - Haskell Community»

Ramin Honary
@ramin_hal9001@fe.disroot.org · Reply to das-g

@das_g True. It is certainly magical that there is a programming language which defines a state monad called “IO” (or sometimes “Effect”) which carries around with it a symbol of the entire Real World in order to model the idea that any evaluation of a function of that type of monad may (or may not) create a change somewhere out in the real world, as opposed to “pure” functions which can only ever manipulate the stack.

#tech #software #Haskell #ProgrammingLanguage #TypeTheory #CategoryTheory

fe.disroot.org

FEDIsroot

das-g
@das_g@chaos.social

🧚 The Real World is deeply magical. ✨

(Or at least type RealWorld is, according to documentation.)

hackage.haskell.org/package/ba

hackage.haskell.org

Control.Monad.ST

DescriptionThis module provides support for strict state threads, as described in the PLDI '94 paper by John Launchbury and Simon Peyton Jones Lazy Functional State Threads.References (variables) that can be used within the ST monad are provided by Data.STRef, and arrays are provided by Data.Array.ST.

DiazCarrete
@DiazCarrete@hachyderm.io

In Haskell, the humble dot . can have several meanings.

- The composition operator hackage.haskell.org/package/ba

- Module separator haskell.org/onlinereport/haske

- With OverloadedRecordDot, field access downloads.haskell.org/ghc/late

First one doesn't cause problems as long as you do the right thing and always surround it with spaces.

The last two can suffer from ambiguity. Are we referring to a qualified value, or (admittedly a rare thing) accessing a field on a datatype constructor?

To resolve the ambiguity, parentheses seem to be enough.

This kind of ambiguity might also happen with the QualifiedDo extension downloads.haskell.org/ghc/late and (if it gets accepted 🤞) the QualifiedLiterals extension github.com/ghc-proposals/ghc-p

Haskell code that fails to compile because GHC assumes "Xoo1.xofi" is a module-qualified name. data Xoo = Xoo1 | Xoo2 instance HasField "xofi" Xoo String where getField _ = "xofi" xooo2 :: String xooo2 = Xoo1.xofi
ALT text

Haskell code that fails to compile because GHC assumes "Xoo1.xofi" is a module-qualified name. data Xoo = Xoo1 | Xoo2 instance HasField "xofi" Xoo String where getField _ = "xofi" xooo2 :: String xooo2 = Xoo1.xofi

Same code as before, corrected by putting parentheses around the Xooo1 constructor. data Xoo = Xoo1 | Xoo2 instance HasField "xofi" Xoo String where getField _ = "xofi" xooo2 :: String xooo2 = (Xoo1).xofi
ALT text

Same code as before, corrected by putting parentheses around the Xooo1 constructor. data Xoo = Xoo1 | Xoo2 instance HasField "xofi" Xoo String where getField _ = "xofi" xooo2 :: String xooo2 = (Xoo1).xofi

Philipp :emacs: :nixos:
@pmidden@fosstodon.org

I'm using 's excellent GitHub workflow to produce statically linked Haskell binaries. It's curious, however, that ghc-9.0.4 produces a binary that's roughly 1MiB in size, whereas 9.4 produces a whopping 30MiB binary. Haven't tested the later ghc versions yet, but I hope they're a bit more conservative w.r.t. size...

Jesper Agdakx 🔸
@jesper@agda.club
and they told me the perfect function name didn't exist..

#Haskell #Lens
The Haddock documentation for the function `confusing` from the Haskell Lens library. It is indeed confusing.
ALT text

The Haddock documentation for the function `confusing` from the Haskell Lens library. It is indeed confusing.

Philipp :emacs: :nixos:
@pmidden@fosstodon.org

Typical packaging situation. I want to decompress a zip file. I search hackage for "zip". Lots of results. The first two are "zip" and "zip-archive". Similar amount of downloads, similar "Last U/L" date. What the hell do I use here? :D I'm now going by number of downloads, where "zip-archive" is the clear winner.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Quasiquoting for fun, profit, expressions and patterns. ~ MLabs. mlabs.city/blog/quasiquoting-f

mlabs.city

Quasiquoting for Fun, Profit, Expressions and Patterns — Mlabs.city

In this post, discover how quasiquoters overcome three key smart-constructor limitations—compile-time errors, lack of pattern matching, and fixed syntax—by leveraging Template Haskell to produce both expressions and patterns with familiar, literal syntax.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Heftia: The final word in Haskell effect system libraries (Part 1.1). ~ Riyo. sayo-hs.github.io/blog/heftia/

sayo-hs.github.io

Heftia: The Final Word in Haskell Effect System Libraries - Part 1.1

heftia is the first-ever fully type-safe and performant effect system, not just among Haskell libraries but historically across all effect system implementations and languages, to completely implement both algebraic effects and higher-order effects.

Haskell Weekly
@haskell_discussions@mastodon.social

State-based testing with quickcheck-lockstep (Haskell Unfolder #44)

youtube.com/watch?index=44&lis

Discussions: discu.eu/q/https://www.youtube

discu.eu

State-based testing with quickcheck-lockstep (Haskell Unfolder #44) - discu.eu

Discussions and related articles for «State-based testing with quickcheck-lockstep (Haskell Unfolder #44)»

Andres Löh
@kosmikus@functional.cafe

If you want to hear from Edsko and me how to test stateful APIs using quickcheck(-lockstep), join us today, 2025-05-14, at 1830 UTC, live on YouTube for a new episode of the : youtube.com/watch?v=RPQVsaZ46D

youtube.com

State-based testing with quickcheck-lockstep (Haskell Unfolder #44)

Many Haskell programmers will be familiar with property based testing of pure functions (for those who are not, various episodes of the Haskell Unfolder have...

Anupam 🇮🇳《ミ》λ≡
@aj@id1.in

Is it just me, or is this a weird post by Sandy Maguire?

The Maybe formulation is incorrect -

`unionWith :: (Maybe a -> Maybe b -> c) -> Map k a -> Map k b -> Map k c`

And that the version with `These` is the right one to use -

`unionWith :: (These a b -> c) -> Map k a -> Map k b -> Map k c`

But then Sandy immediately discards this formulation, and instead builds up a monoidal strawman, which is equivalent to the Maybe formulation, to knock down. To get some law that doesn't hold anyway?

https://reasonablypolymorphic.com/blog/api-analysis/

#Haskell

reasonablypolymorphic.com

Analyzing API Design via Algebraic Laws :: Reasonably Polymorphic

Anupam 🇮🇳《ミ》λ≡
@aj@id1.in

Is it just me, or is this a weird post by Sandy Maguire?

The Maybe formulation is incorrect -

`unionWith :: (Maybe a -> Maybe b -> c) -> Map k a -> Map k b -> Map k c`

And that the version with `These` is the right one to use -

`unionWith :: (These a b -> c) -> Map k a -> Map k b -> Map k c`

But then Sandy immediately discards this formulation, and instead builds up a monoidal strawman, which is equivalent to the Maybe formulation, to knock down. To get some law that doesn't hold anyway?

https://reasonablypolymorphic.com/blog/api-analysis/

#Haskell

reasonablypolymorphic.com

Analyzing API Design via Algebraic Laws :: Reasonably Polymorphic

Fraser Tweedale
@hackuador@functional.cafe

Brisbane Functional Programming Group THIS TUESDAY. Compiling parametric polymorphism (Isaac Elliott) + 2 years of the Security Response Team (Fraser Tweedale). See yas there, curious minds. lu.ma/yfkrxawh

lu.ma

BFPG Meetup - May 2025 - Compiling parametric polymorphism + Haskell Security Team · Luma

Join the BFPG Discord: https://discord.gg/yYz2d8w7FY Agenda 18:00: Welcome and setup Presentation #1: A "third way" of compiling parametric polymorphism -…

Haskell Weekly
@haskell_discussions@mastodon.social

Full Time Nix | Horizon Haskell with Daniel Firth (Podcast)

fulltimenix.com/episodes/horiz

Discussions: discu.eu/q/https://fulltimenix

discu.eu

Full Time Nix | Horizon Haskell with Daniel Firth - discu.eu

Discussions and related articles for «Full Time Nix | Horizon Haskell with Daniel Firth»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared May 9, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared May 9, 2025

The readings shared in Bluesky on 9 May 2025 are - Proof assistants for teaching: A survey. ~ Frédéric Tran Minh, Laure Gonnord and Julien Narboux. #ATP #ITP #IsabelleHOL #LeanProver #Coq #Rocq #Edu

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared May 8, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared May 8, 2025

The readings shared in Bluesky on 8 May 2025 are SAT-solving the poset cover problem. ~ Chih-Cheng Rex Yuan, Bow-Yaw Wang. #ATP #SATsolvers #Z3 FormalMATH: Benchmarking formal mathematical reasoning

Haskell Weekly
@haskell_discussions@mastodon.social

Haskell's killer app is maintainability

taylor.fausak.me/2019/11/17/ha

Discussions: discu.eu/q/https://taylor.faus

discu.eu

Haskell’s killer app is maintainability · taylor.fausak.me - discu.eu

Discussions and related articles for «Haskell’s killer app is maintainability · taylor.fausak.me»

Haskell Weekly
@haskell_discussions@mastodon.social

From Haskell to a New Structured Combinator Processor

researchportal.hw.ac.uk/en/pub

Discussions: discu.eu/q/https://researchpor

discu.eu

From Haskell to a New Structured Combinator Processor - discu.eu

Discussions and related articles for «From Haskell to a New Structured Combinator Processor»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Compiling Haskell into Lean: A common abstract syntax for Haskell and interactive theorem provers. ~ Talitha Holcombe. digitalcommons.chapman.edu/eec

digitalcommons.chapman.edu

Compiling Haskell into Lean: A Common Abstract Syntax for Haskell and Interactive Theorem Provers

In this work, we introduce a program conversion tool, HS-TO-LEAN, that uses GHC's ghc-lib-parser API to translate Haskell programs into Lean code, which is then validated by the Lean compiler. The repo can be found at https://github.com/holcombet/hs-to-lean/tree/main. The result is a successful compilation of a fragment of Haskell into correct and executable Lean code that users can prove theorems about. We conducted a case study using a heap sort algorithm to support our claim that HS-TO-LEAN produces verifiable Lean code. Our approach is inspired by recent advances in formal verification of Haskell programs in Coq, and we currently restrict our attention to total Haskell. The compiler produces an AST that serves as a common level of abstraction between a fragment of Haskell and Lean. The abstract common fragment promotes translation between languages by simplifying and restructuring GHC's original AST, improving the readability and linearization of the AST. Future work on HS-TO-LEAN will extend the compiler to translate to other interactive theorem provers, including Coq, Agda, and Isabelle, making it portable and accessible to a range of verification efforts and communities. Future work also includes implementing bidirectionality, supporting the translation of Haskell code to a target proof assistant and vice versa. This method will expose an interesting level of abstraction that is applicable to all of the languages involved and produce a more maintainable compiler. These results contribute to the ongoing work in the formalization and verification of mathematics and programming and present a viable approach to unifying the formal systems of different proof assistants.

Haskell Weekly
@haskell_discussions@mastodon.social

Simon Peyton Jones on fearless refactoring over the long term in Haskell

discourse.haskell.org/t/emphas

Discussions: discu.eu/q/https://discourse.h

discu.eu

Emphasize "Why Haskell?" on haskell.org landing page - Haskell Community - discu.eu

Discussions and related articles for «Emphasize "Why Haskell?" on haskell.org landing page - Haskell Community»

Haskell Weekly
@haskell_discussions@mastodon.social

The Haskell Unfolder Episode 43: monomorphism restriction and defaulting

youtube.com/watch?index=43&lis

Discussions: discu.eu/q/https://www.youtube

discu.eu

The Haskell Unfolder Episode 43: monomorphism restriction and defaulting - YouTube - discu.eu

Discussions and related articles for «The Haskell Unfolder Episode 43: monomorphism restriction and defaulting - YouTube»

Andres Löh
@kosmikus@functional.cafe

Today, there will be a new episode, where Edsko and I will talk about the monomorphism restriction and defaulting. Join us live on YouTube 2025-05-07 at 1830 UTC (or watch later) via youtube.com/watch?v=nD93M2qlwM

youtube.com

The Haskell Unfolder Episode 43: monomorphism restriction and defaulting

In this episode, we are going to look at two interacting "features" of the Haskell language (the monomorphism restriction and defaulting) that can be somewha...

Andres Löh
@kosmikus@functional.cafe

Today, there will be a new episode, where Edsko and I will talk about the monomorphism restriction and defaulting. Join us live on YouTube 2025-05-07 at 1830 UTC (or watch later) via youtube.com/watch?v=nD93M2qlwM

youtube.com

The Haskell Unfolder Episode 43: monomorphism restriction and defaulting

In this episode, we are going to look at two interacting "features" of the Haskell language (the monomorphism restriction and defaulting) that can be somewha...

Haskell Weekly
@haskell_discussions@mastodon.social

Prompt chaining reimagined with type inference

haskellforall.com/2025/05/prom

Discussions: discu.eu/q/https://www.haskell

discu.eu

Haskell for all: Prompt chaining reimagined with type inference - discu.eu

Discussions and related articles for «Haskell for all: Prompt chaining reimagined with type inference»

Haskell Weekly
@haskell_discussions@mastodon.social

ihaskell + dataframe integration

github.com/mchav/dataframe/blo

Discussions: discu.eu/q/https://github.com/

discu.eu

dataframe/docs/California Housing.ipynb at main · mchav/dataframe · GitHub - discu.eu

Discussions and related articles for «dataframe/docs/California Housing.ipynb at main · mchav/dataframe · GitHub»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Compiling Haskell into Lean: A common abstract syntax for Haskell and interactive theorem provers. ~ Talitha Holcombe. digitalcommons.chapman.edu/eec

digitalcommons.chapman.edu

Compiling Haskell into Lean: A Common Abstract Syntax for Haskell and Interactive Theorem Provers

In this work, we introduce a program conversion tool, HS-TO-LEAN, that uses GHC's ghc-lib-parser API to translate Haskell programs into Lean code, which is then validated by the Lean compiler. The repo can be found at https://github.com/holcombet/hs-to-lean/tree/main. The result is a successful compilation of a fragment of Haskell into correct and executable Lean code that users can prove theorems about. We conducted a case study using a heap sort algorithm to support our claim that HS-TO-LEAN produces verifiable Lean code. Our approach is inspired by recent advances in formal verification of Haskell programs in Coq, and we currently restrict our attention to total Haskell. The compiler produces an AST that serves as a common level of abstraction between a fragment of Haskell and Lean. The abstract common fragment promotes translation between languages by simplifying and restructuring GHC's original AST, improving the readability and linearization of the AST. Future work on HS-TO-LEAN will extend the compiler to translate to other interactive theorem provers, including Coq, Agda, and Isabelle, making it portable and accessible to a range of verification efforts and communities. Future work also includes implementing bidirectionality, supporting the translation of Haskell code to a target proof assistant and vice versa. This method will expose an interesting level of abstraction that is applicable to all of the languages involved and produce a more maintainable compiler. These results contribute to the ongoing work in the formalization and verification of mathematics and programming and present a viable approach to unifying the formal systems of different proof assistants.

DiazCarrete
@DiazCarrete@hachyderm.io

"Data.Graph.stronglyConnCompR" from "containers" distinguishes between isolated vertices and vertices with self-loops, which is the behavior I needed 👍
hackage-content.haskell.org/pa
hackage-content.haskell.org/pa

ghci> import Data.Graph ghci> stronglyConnCompR [((),"foo",[])] [AcyclicSCC ((),"foo",[])] ghci> stronglyConnCompR [((),"foo",["foo"])] [NECyclicSCC (((),"foo",["foo"]) :| [])]
ALT text

ghci> import Data.Graph ghci> stronglyConnCompR [((),"foo",[])] [AcyclicSCC ((),"foo",[])] ghci> stronglyConnCompR [((),"foo",["foo"])] [NECyclicSCC (((),"foo",["foo"]) :| [])]

Abhinav 🧭
@abnv@fantastic.earth

I've created a PR in , a simple setup framework, to add support for easy building of statically-linked executables (github.com/pwm/nixkell/pull/50). I'd appreciate it if any Nixkell users gives it a try for their projects. I've been using this code for a couple of my projects, and it works fine for me, but I'd like to have more working examples.

github.com

Add support for building statically-linked executable by abhin4v · Pull Request #50 · pwm/nixkell

This PR adds support for easily building statically-linked executable using Nixkell and Nix. Majorly, it: adds an overlays-static.nix file that configures GHC and Haskell packages for building sta...

Haskell Weekly
@haskell_discussions@mastodon.social

GHC String Interpolation Survey - Final Results

discourse.haskell.org/t/ghc-st

Discussions: discu.eu/q/https://discourse.h

discu.eu

GHC String Interpolation Survey - Final Results - Haskell Community - discu.eu

Discussions and related articles for «GHC String Interpolation Survey - Final Results - Haskell Community»

Haskell Weekly
@haskell_discussions@mastodon.social

[Well-Typed] Explicit Level Imports awarded best paper at TFP 2025

well-typed.com/blog/2025/04/ex

Discussions: discu.eu/q/https://www.well-ty

discu.eu

Explicit Level Imports awarded best paper at TFP 2025 - Well-Typed: The Haskell Consultants - discu.eu

Discussions and related articles for «Explicit Level Imports awarded best paper at TFP 2025 - Well-Typed: The Haskell Consultants»

Haskell Weekly
@haskell_discussions@mastodon.social

[Well-Typed] Explicit Level Imports awarded best paper at TFP 2025

well-typed.com/blog/2025/04/ex

Discussions: discu.eu/q/https://www.well-ty

discu.eu

Explicit Level Imports awarded best paper at TFP 2025 - Well-Typed: The Haskell Consultants - discu.eu

Discussions and related articles for «Explicit Level Imports awarded best paper at TFP 2025 - Well-Typed: The Haskell Consultants»

DiazCarrete
@DiazCarrete@hachyderm.io

Explicit Level Imports awarded best paper at TFP 2025
well-typed.com/blog/2025/04/ex
The paper (pdf) well-typed.com/blog/aux/files/

In a cross-compilation setting, the need for the stage distinction is even clearer, because the runtime stage needs programs that run on the target architecture, whereas the compile-time stage expects programs to run on the host. Cross-compilers may benefit from three or more stages (see section 5.7). Levels and stages are often confused in literature but for clarity it is important to distinguish between them [16]. Both may be represented as numbers, but levels are offsets (differences relative to common reference point), whereas stages are absolute values. Levels are a type-system concept as part of the specification of valid programs, whereas stages are an implementation detail of the compiler.
ALT text

In a cross-compilation setting, the need for the stage distinction is even clearer, because the runtime stage needs programs that run on the target architecture, whereas the compile-time stage expects programs to run on the host. Cross-compilers may benefit from three or more stages (see section 5.7). Levels and stages are often confused in literature but for clarity it is important to distinguish between them [16]. Both may be represented as numbers, but levels are offsets (differences relative to common reference point), whereas stages are absolute values. Levels are a type-system concept as part of the specification of valid programs, whereas stages are an implementation detail of the compiler.

Ultimately, cross-stage persistence forces the build system to compile all modules and require all dependencies for all stages, even if the final program uses only a small fragment of its dependency tree at any particular stage. 3 Implicit stage-persistence considered harmful Implicit stage persistence seems convenient at first, but is the root of many performance and cross-compilation issues in practice. If imported identifiers can be arbitrarily used at any stage, the compiler must pessimistically assume they will be used at all stages, and therefore it needs to compile all modules in a project for both runtime and compile-time. Our design allows implicit path-based cross-stage persistence to be disabled. Identifiers must be used at precisely the level they are bound, and no other levels. Instead, we should be able to explicitly control the level at which identifiers from a module are imported. By being very precise about which levels modules are needed at, there are many real-world advantages: 1. Currently, if a module enables TemplateHaskell, then all imported modules are compiled to object code before name resolution takes place. This ensures that any top level splices that may be encountered are able to be fully evaluated. This is a pessimisation because most of the imported identifiers, which we have taken such pains to ensure we can run, will not actually be used in a top-level splice.
ALT text

Ultimately, cross-stage persistence forces the build system to compile all modules and require all dependencies for all stages, even if the final program uses only a small fragment of its dependency tree at any particular stage. 3 Implicit stage-persistence considered harmful Implicit stage persistence seems convenient at first, but is the root of many performance and cross-compilation issues in practice. If imported identifiers can be arbitrarily used at any stage, the compiler must pessimistically assume they will be used at all stages, and therefore it needs to compile all modules in a project for both runtime and compile-time. Our design allows implicit path-based cross-stage persistence to be disabled. Identifiers must be used at precisely the level they are bound, and no other levels. Instead, we should be able to explicitly control the level at which identifiers from a module are imported. By being very precise about which levels modules are needed at, there are many real-world advantages: 1. Currently, if a module enables TemplateHaskell, then all imported modules are compiled to object code before name resolution takes place. This ensures that any top level splices that may be encountered are able to be fully evaluated. This is a pessimisation because most of the imported identifiers, which we have taken such pains to ensure we can run, will not actually be used in a top-level splice.

resolution depends on code generation for all dependencies. By distinguishing the small fraction of imported modules whose code is executed only at compile time, we are able to improve this pessimisation. 2. GHC offers an -fno-code flag that instructs the compiler to parse and typecheck Haskell modules, but not to generate code, so as to offer quicker feedback to the user. However, any modules imported by a module using TemplateHaskell must be compiled to object code, despite the fact that we will not generate object code for the module itself. By distinguishing imported modules whose code is executed only at compile time, we can eliminate or significantly reduce this unnecessary work. 3. IDEs such as Haskell Language Server face similar problems: they are interested only in the result of type-checking, but when TemplateHaskell is enabled, many modules have to be unnecessarily compiled to bytecode. 4. Currently, when cross-compiling modules that use TemplateHaskell, all splices are executed on the target even though compilation takes place on a separate host. This is a source of significant complexity. This work is a step towards properly distinguishing dependencies that need to be compiled for and executed on the host from those compiled for the target.
ALT text

resolution depends on code generation for all dependencies. By distinguishing the small fraction of imported modules whose code is executed only at compile time, we are able to improve this pessimisation. 2. GHC offers an -fno-code flag that instructs the compiler to parse and typecheck Haskell modules, but not to generate code, so as to offer quicker feedback to the user. However, any modules imported by a module using TemplateHaskell must be compiled to object code, despite the fact that we will not generate object code for the module itself. By distinguishing imported modules whose code is executed only at compile time, we can eliminate or significantly reduce this unnecessary work. 3. IDEs such as Haskell Language Server face similar problems: they are interested only in the result of type-checking, but when TemplateHaskell is enabled, many modules have to be unnecessarily compiled to bytecode. 4. Currently, when cross-compiling modules that use TemplateHaskell, all splices are executed on the target even though compilation takes place on a separate host. This is a source of significant complexity. This work is a step towards properly distinguishing dependencies that need to be compiled for and executed on the host from those compiled for the target.

In section 2.3 we said that modules were compiled for either the C or R stages. Levelled imports make it possible to be precise about what stages we need dependencies. – The main module is compiled for R. This is where the main function lives and the entry-point to running the resulting executable. – A normal import does not shift the stage at which the dependent module is required. – If a module M splice imports module A, then compiling M@R requires compiling module A@C. – If a module M splice imports module A, then compiling M@C requires compiling module A@C. – If a module N quote imports module B, then compiling N@C requires compiling module B at N@R. – If a module N quote imports module B, then compiling N@R requires compiling module B at N@R Stage arithmetic is saturating. Thus, when there are two stages, a quote import corresponds to requiring the module at R, and a splice import to requiring a module at C. When there are more than two stages then the imports can have different meanings depending on the stage a module is compiled for. The compiler can then choose appropriately how modules needed at C are compiled and how modules needed at R are compiled. For example: – In -fno-code mode, C modules may be compiled in dynamic way, but R modules are not compiled at all. – When using a profiled GHC. C modules must be compiled in profiled way but R modules will be compiled in static way.
ALT text

In section 2.3 we said that modules were compiled for either the C or R stages. Levelled imports make it possible to be precise about what stages we need dependencies. – The main module is compiled for R. This is where the main function lives and the entry-point to running the resulting executable. – A normal import does not shift the stage at which the dependent module is required. – If a module M splice imports module A, then compiling M@R requires compiling module A@C. – If a module M splice imports module A, then compiling M@C requires compiling module A@C. – If a module N quote imports module B, then compiling N@C requires compiling module B at N@R. – If a module N quote imports module B, then compiling N@R requires compiling module B at N@R Stage arithmetic is saturating. Thus, when there are two stages, a quote import corresponds to requiring the module at R, and a splice import to requiring a module at C. When there are more than two stages then the imports can have different meanings depending on the stage a module is compiled for. The compiler can then choose appropriately how modules needed at C are compiled and how modules needed at R are compiled. For example: – In -fno-code mode, C modules may be compiled in dynamic way, but R modules are not compiled at all. – When using a profiled GHC. C modules must be compiled in profiled way but R modules will be compiled in static way.

Fraser Tweedale
@hackuador@functional.cafe

Brisbane Functional Programming Group May meetup Tue 2025-05-13. Compiling parametric polymorphism (Isaac Elliott) + 2 years of the Security Response Team (Fraser Tweedale). Be there or a be a lambda cube! lu.ma/yfkrxawh

lu.ma

BFPG Meetup - May 2025 - Compiling parametric polymorphism + Haskell Security Team · Luma

Join the BFPG Discord: https://discord.gg/yYz2d8w7FY Agenda 18:00: Welcome and setup Presentation #1: A "third way" of compiling parametric polymorphism -…

Haskell Weekly
@haskell_discussions@mastodon.social

From 1 to 100k users: Lessons learned from scaling a Haskell app - Felix Miño | Lambda Days 2024

youtube.com/watch?v=1LEjxwahQgY

Discussions: discu.eu/q/https://www.youtube

discu.eu

From 1 to 100k users: Lessons learned from scaling a Haskell app - Felix Miño | Lambda Days 2024 - discu.eu

Discussions and related articles for «From 1 to 100k users: Lessons learned from scaling a Haskell app - Felix Miño | Lambda Days 2024»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared April 25, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared April 25, 2025

The readings shared in Bluesky on 25 April 2025 are Lean 4 formalization of the logic textbook "Logic Notes" by Lou van den Dries. ~ Will Bradley. #ITP #LeanProver #Logic #Math Neural theorem proving

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Magical Haskell: A friendly approach to modern functional programming, type theory, and artificial intelligence. ~ Anton Antich. books.google.com/books?id=aLBW

books.google.com

Magical Haskell

Discover a unique and fun approach to adopting modern typed functions programming patterns. This book uses playful metaphors and examples to help you learn Haskell through imagination, building on math without relying on imperative crutches or technical complexity. You’ll use math to build completely different Typed Functional patterns from the ground up and understand the link between building Mathematics through Types and constructing Haskell as a programming language. Intended for working with various applications, especially AI-powered apps, the book gently builds up to what are normally considered complex and difficult concepts all without needing a PhD to understand them. Illustrative explanations will guide you to tackle monads, using monad transformer stacks to structure real programs, foldable and traversable structures, as well as other Type classes. This book will also help you structure programs efficiently and apply your own abstractions to real-life problem domains. Next, you’ll explore exciting advancements in AI, including building with OpenAI APIs, creating a terminal chatbot, adding web functionality, and enhancing with retrieval-augmented generation. Finally, you’ll delve into AI multi-agents and future directions using Arrows abstraction, reinforcing Haskell’s design. Magical Haskell is a solution for programmers who feel limited by imperative programming languages but are also put off by excessively mathematical approaches. What You Will Learn Grasp a solid math foundation without complex technicalities for Types and Typeclasses. Solve problems via a typed functional approach and understand why it’s superior to what’s available in the imperative language world (“if it compiles, it runs”). Build your own abstractions to efficiently resolve problems in any given domain. Develop AI frameworks in Haskell, including chatbots, web functionality, and retrieval-augmented generation. Who This Book Is For Haskell programmers of all levels and those interested in Type Theory.

Haskell Weekly
@haskell_discussions@mastodon.social

Implementing Unsure Calculator in 100 lines of Haskell

alt-romes.github.io/posts/2025

Discussions: discu.eu/q/https://alt-romes.g

discu.eu

Implementing Unsure Calculator in 100 lines of Haskell - discu.eu

Discussions and related articles for «Implementing Unsure Calculator in 100 lines of Haskell»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared April 23, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared April 23, 2025

The readings shared in Bluesky on 23 April 2025 are Bullshit universities: the future of automated education. ~ Robert Sparrow, Gene Flenady. #GenerativeAI #Education #Exercitium: Suma de cadenas. #H

Haskell Weekly
@haskell_discussions@mastodon.social

Broad search for any Traversable

github.com/effectfully-ou/hask

Discussions: discu.eu/q/https://github.com/

discu.eu

haskell-challenges/h9-traversable-search at master · effectfully-ou/haskell-challenges · GitHub - discu.eu

Discussions and related articles for «haskell-challenges/h9-traversable-search at master · effectfully-ou/haskell-challenges · GitHub»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared April 22, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared April 22, 2025

The readings shared in Bluesky on 22 April 2025 are The inverse method is a good fit for Datalog theorem proving. ~ Philip Zucker. #Datalog #Logic In between myth and reality: AI for math (a case stu

DiazCarrete
@DiazCarrete@hachyderm.io

"Writing modules with the assumption they will be imported qualified made a big improvement to my Haskell code."

discourse.haskell.org/t/long-f

discourse.haskell.org

Long function names for real-world code

When reading other people’s code, I found the following combination a good trade-off between succinctness and clarity: qualified imports concise names in imported modules (like @elaforge) suggested Haddock-generated source annotation that gives you the type and module as tool-tip and hyperlinks 100% agree with this advice. Writing modules with the assumption they will be imported qualified made a big improvement to my Haskell code. It’s a great tool for reflecting context in the way I was ...

Haskell Weekly
@haskell_discussions@mastodon.social

GHC String Interpolation - Final Survey

discourse.haskell.org/t/ghc-st

Discussions: discu.eu/q/https://discourse.h

discu.eu

GHC String Interpolation - Final Survey - Announcements - Haskell Community - discu.eu

Discussions and related articles for «GHC String Interpolation - Final Survey - Announcements - Haskell Community»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared April 21, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared April 21, 2025

The readings shared in Bluesky on 21 April 2025 are A formalisation of Aristotle’s assertoric syllogistic in Isabelle/HOL. ~ Angeliki Koutsoukou-Argyraki, Karol Wapniarski. #ITP #IsabelleHOL #Logic N

ZuriHac
@zurihac@fosstodon.org

Greetings ZuriHackers!

Do you have a project you want to work on during ZuriHac? Now is a great time to get some contributors on board!

Do you not have a project yet? Then perhaps you want to have a look to get an idea about what others are working on!

Please find already registered projects at
zfoh.ch/zurihac2025/projects/ or submit a PR at github.com/zfoh/zfoh.ch/edit/m!

github.com

Build software better, together

GitHub is where people build software. More than 150 million people use GitHub to discover, fork, and contribute to over 420 million projects.

ZuriHac
@zurihac@fosstodon.org

Greetings ZuriHackers!

Do you have a project you want to work on during ZuriHac? Now is a great time to get some contributors on board!

Do you not have a project yet? Then perhaps you want to have a look to get an idea about what others are working on!

Please find already registered projects at
zfoh.ch/zurihac2025/projects/ or submit a PR at github.com/zfoh/zfoh.ch/edit/m!

github.com

Build software better, together

GitHub is where people build software. More than 150 million people use GitHub to discover, fork, and contribute to over 420 million projects.

harryprayiv
@harryprayiv@mastodon.social

If you’re a user or a proponent of please consider donating to the project to keep it alive.

It’s a fairly obscure project but, IMO, it is THE language for web .

On top of that, the backend was recently rewritten in which tends to be very popular choice in the world due to its rigor.

I see nipping at its heels but IMO, PS will always be a more bespoke and opinionated tool.

opencollective.com/purescript/

opencollective.com

Contribute - Open Collective

harryprayiv
@harryprayiv@mastodon.social

If you’re a user or a proponent of please consider donating to the project to keep it alive.

It’s a fairly obscure project but, IMO, it is THE language for web .

On top of that, the backend was recently rewritten in which tends to be very popular choice in the world due to its rigor.

I see nipping at its heels but IMO, PS will always be a more bespoke and opinionated tool.

opencollective.com/purescript/

opencollective.com

Contribute - Open Collective

Haskell Weekly
@haskell_discussions@mastodon.social

"Extensible Records Problem"

docs.google.com/spreadsheets/d

Discussions: discu.eu/q/https://docs.google

discu.eu

Haskell record variant comparison - Google Sheets - discu.eu

Discussions and related articles for «Haskell record variant comparison - Google Sheets»

Haskell Weekly
@haskell_discussions@mastodon.social

GSoC proposal : Documenting and improving cmm

discourse.haskell.org/t/gsoc-2

Discussions: discu.eu/q/https://discourse.h

discu.eu

GSoC 2025: Documenting and Improving Cmm - Show and Tell - Haskell Community - discu.eu

Discussions and related articles for «GSoC 2025: Documenting and Improving Cmm - Show and Tell - Haskell Community»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared April 19, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared April 19, 2025

The readings shared in Bluesky on 19 April 2025 are Knuckledragger: A low barrier proof assistant. ~ Philip Zucker. #ITP #SMT #Z3 #Python Neural theorem proving tutorial. ~ Sean Welleck. #MachineLear

Haskell Weekly
@haskell_discussions@mastodon.social

falsify: Hypothesis-inspired shrinking for Haskell

well-typed.com/blog/2023/04/fa

Discussions: discu.eu/q/https://well-typed.

discu.eu

falsify: Hypothesis-inspired shrinking for Haskell - Well-Typed: The Haskell Consultants - discu.eu

Discussions and related articles for «falsify: Hypothesis-inspired shrinking for Haskell - Well-Typed: The Haskell Consultants»

Ben Gamari
@bgamari@mastodon.social

GHC 9.10.2 release candidate 1 is now available for your testing. This is a big release for a minor release; far too many bug fixes to list. As always, please do open a ticket if you findanything amiss.

Happy Haskelling!

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

The Haskell Unfolder Episode 42: Logic programming with typedKanren. ~ Edsko de Vries, Andres Löh. youtube.com/live/ukk5JDRYQSc

youtube.com

The Haskell Unfolder Episode 42: logic programming with typedKanren

Functional programming is programming with mathematical functions, mapping inputs to outputs. By contrast, logic programming---perhaps best known from the la...

Haskell Weekly
@haskell_discussions@mastodon.social

The Haskell Unfolder Episode 42: logic programming with typedKanren

youtube.com/watch?index=42&lis

Discussions: discu.eu/q/https://www.youtube

discu.eu

The Haskell Unfolder Episode 42: logic programming with typedKanren - discu.eu

Discussions and related articles for «The Haskell Unfolder Episode 42: logic programming with typedKanren»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared April 15, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared April 15, 2025

The readings shared in Bluesky on 15 April 2025 are Simplified and verified: A second look at a proof-producing union-find algorithm. ~ Lukas Stevens, Rebecca Ghidini. #ITP #IsabelleHOL First-order r

Andres Löh
@kosmikus@functional.cafe

The is two years old! Join us for a new episode tomorrow, 2025-04-16, at 1830 UTC, live on YouTube. This time, the topic is logic programming with typedKanren, which is a typed version of embedded into Haskell.

youtube.com/watch?v=ukk5JDRYQS

youtube.com

The Haskell Unfolder Episode 42: logic programming with typedKanren

Functional programming is programming with mathematical functions, mapping inputs to outputs. By contrast, logic programming---perhaps best known from the la...

Haskell Weekly
@haskell_discussions@mastodon.social

Evaluating AI's Impact on Haskell Open Source Development

well-typed.com/blog/2025/04/ai

Discussions: discu.eu/q/https://www.well-ty

discu.eu

Evaluating AI's Impact on Haskell Open Source Development - Well-Typed: The Haskell Consultants - discu.eu

Discussions and related articles for «Evaluating AI's Impact on Haskell Open Source Development - Well-Typed: The Haskell Consultants»

Haskell Weekly
@haskell_discussions@mastodon.social

"Super Haskell": an introduction to Agda by André Muricy

adabeat.com/fps/super-haskell-

Discussions: discu.eu/q/https://adabeat.com

discu.eu

"Super Haskell": an introduction to Agda by André Muricy - Ada Beat - discu.eu

Discussions and related articles for «"Super Haskell": an introduction to Agda by André Muricy - Ada Beat»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared April 13, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared April 13, 2025

The readings shared in Bluesky on 13 April 2025 are Completeness of decreasing diagrams for the least uncountable cardinality (in Isabelle/HOL). ~ Ievgen Ivanov. #ITP #IsabelleHOL #Math #SetTheory Ef

Boyd Stephen Smith Jr.
@BoydStephenSmithJr@hachyderm.io

Whelp. Just got let go. They actually disabled my account while I was in the exit interview. Corporate IT is _cold_.

Anyway, I guess I'm looking for a new position maybe even be ?

I have to live in Cove, AR with my disabled family, so it will probably need to be 100% remote.

I'd prefer to keep doing or try out in production, or even something more exotic like or

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared April 11, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared April 11, 2025

The readings shared in Bluesky on 11 April 2025 are Code generation via meta-programming in dependently typed proof assistants. ~ Mathis Bouverot-Dupuis, Yannick Forster. #ITP #Agda #Rocq #LeanProver

Boyd Stephen Smith Jr.
@BoydStephenSmithJr@hachyderm.io

Whelp. Just got let go. They actually disabled my account while I was in the exit interview. Corporate IT is _cold_.

Anyway, I guess I'm looking for a new position maybe even be ?

I have to live in Cove, AR with my disabled family, so it will probably need to be 100% remote.

I'd prefer to keep doing or try out in production, or even something more exotic like or

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared April 10, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared April 10, 2025

The readings shared in Bluesky on 10 April 2025 are Canonical for automated theorem proving in Lean. ~ Chase Norman, Jeremy Avigad. #ITP #LeanProver #Math Formalization of gyrovector spaces as models

Haskell Weekly
@haskell_discussions@mastodon.social

Purely Functional Sliding Window Aggregation Algorithm

byorgey.github.io/blog/posts/2

Discussions: discu.eu/q/https://byorgey.git

discu.eu

blog :: Brent -> [String] - Competitive Programming in Haskell: stacks, queues, and monoidal sliding windows - discu.eu

Discussions and related articles for «blog :: Brent -> [String] - Competitive Programming in Haskell: stacks, queues, and monoidal sliding windows»

Rafaelito 🦤
@ipxfong@mastodon.sdf.org

Hey my Haskell curious friends. When I got started I picked up a copy of Learn You a Haskell. It's good but for someone who thought that functional programming meant breaking your c code into functions, it's a bit like sipping from the fire hose. I picked up a copy of Haskell: The Craft of Functional Programming. It's got a lot more background on how to think about Functional Programming. Paper copies are cheap but you can get a copy here for free: haskellcraft.com/craft3e/Home.

haskellcraft.com

Haskell: the Craft of Functional Programming

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared April 8, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared April 8, 2025

The readings shared in Bluesky on 8 April 2025 are DMTL4: Discrete mathematics and theory in Lean 4. ~ Kevin Sullivan. #ITP #LeanProver #Math Course Cs2120f24: Discrete mathematics and theory in Lean

Francesco
@ffaff@aleph.land

cabal-install 3.14.2.0 released
discourse.haskell.org/t/cabal-
With a number of very important regression fixes! Try it now!

Many thanks to our release manager Mikolaj Konarski and all contributors!
Boosts for reach appreciated!

discourse.haskell.org

Cabal-install 3.14.2.0 released

Cabal team is happy to announce the release of cabal-install tool version 3.14.2.0 and related libraries. Early adopters that have switched to the vanilla ghcup channel can already install it via ghcup install cabal 3.14.2.0 && ghcup set cabal 3.14.2.0 while others may want to wait for the main ghcup channel to include the release, possibly with more architectures supported than on the vanilla channel. Another early adopter option is ghcup --no-cache install cabal -u 'https://gitlab.haskell.o...

Francesco
@ffaff@aleph.land

cabal-install 3.14.2.0 released
discourse.haskell.org/t/cabal-
With a number of very important regression fixes! Try it now!

Many thanks to our release manager Mikolaj Konarski and all contributors!
Boosts for reach appreciated!

discourse.haskell.org

Cabal-install 3.14.2.0 released

Cabal team is happy to announce the release of cabal-install tool version 3.14.2.0 and related libraries. Early adopters that have switched to the vanilla ghcup channel can already install it via ghcup install cabal 3.14.2.0 && ghcup set cabal 3.14.2.0 while others may want to wait for the main ghcup channel to include the release, possibly with more architectures supported than on the vanilla channel. Another early adopter option is ghcup --no-cache install cabal -u 'https://gitlab.haskell.o...

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

: Elementos de una matriz con algún vecino menor. jaalonso.github.io/exercitium/

jaalonso.github.io

Elementos de una matriz con algún vecino menor

Las matrices puede representarse mediante tablas cuyos índices son pares de números naturales. Su tipo se define por type Matriz = Array (Int,Int) Int Por ejemplo, la matriz |9 4 6 5| |8 1 7 3| |4 2

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Verified program extraction in number theory: The fundamental theorem of arithmetic and relatives. ~ Franziskus Wiesnet. arxiv.org/abs/2504.03460

arxiv.org

Verified Program Extraction in Number Theory: The Fundamental Theorem of Arithmetic and Relatives

This article revisits standard theorems from elementary number theory through a constructive, algorithmic, and proof-theoretic lens, within the theory of computable functionals. Key examples include Bèzout's identity, the fundamental theorem of arithmetic, and Fermat's factorization method. All definitions and theorems are fully formalized in the proof assistant Minlog, thereby laying the foundation for a comprehensive formal framework for number theory within Minlog. While formalization ensures correctness, our primary emphasis is on the computational content of proofs. Leveraging Minlog's built-in program extraction, we obtain executable terms that are exported as Haskell code. Efficiency of the extracted programs plays a central role. We show how performance considerations influence even the initial formulation of theorems and proofs. In particular, we compare formalizations based on binary encodings of natural numbers with those using the traditional unary (successor-based) representation. We present several core proofs in detail and reflect on the challenges that arise from formalization in contrast to informal reasoning. The complete formalisation is available online and linked for reference. Minlog's tactic scripts are designed to follow the structure of natural-language proofs, allowing each derivation step to be traced precisely and helping to bridge the gap between formal and classical mathematical reasoning.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared April 6, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared April 6, 2025

The readings shared in Bluesky on 6 April 2025 are Prolog vs LLMs: A complementary approach to AI (according to DeepSeek). #Prolog #LogicProgramming #LLMs #AI #Exercitium: Enumeración de árboles bina

Haskell Weekly
@haskell_discussions@mastodon.social

The Open-Closed Principle - Part 2 - The Contemporary Version - An Introduction - oldie but goodie

fpilluminated.org/deck/259

Discussions: discu.eu/q/https://fpilluminat

discu.eu

The Open-Closed Principle - Part 2 - The Contemporary Version - An Introduction - discu.eu

Discussions and related articles for «The Open-Closed Principle - Part 2 - The Contemporary Version - An Introduction»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared April 5, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared April 5, 2025

The readings shared in Bluesky on 5 April 2025 are Building AI for mathematical reasoning. ~ Chris Garcia. #Prolog #LogicProgramming #Logic #Math #Exercitium: Números triangulares con n cifras distin

Haskell Weekly
@haskell_discussions@mastodon.social

What chapters from the GHC User's Guide you'd recommend?

lexi-lambda.github.io/blog/202

Discussions: discu.eu/q/https://lexi-lambda

discu.eu

An introduction to typeclass metaprogramming - discu.eu

Discussions and related articles for «An introduction to typeclass metaprogramming»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared April 4, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared April 4, 2025

The readings shared in Bluesky on 4 April 2025 are Learning Lean in the age of Artificial Intelligence. ~ Adolfo Neto. #ITP #LeanProver Guessing game: Haskell style. ~ kqr. #Haskell #FunctionalProgra

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared April 3, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared April 3, 2025

The readings shared in Bluesky on 3 April 2025 are Morley's theorem (in Isabelle/HOL). ~ Benjamin Puyobro. #ITP #IsabelleHOL #Math Category theory using Haskell (An introduction with Moggi and Yoneda

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Category theory using Haskell (An introduction with Moggi and Yoneda). ~ Shuichi Yukita. books.google.com/books?id=4Xc2

books.google.com

Category Theory Using Haskell

This unique book offers an introductory course on category theory, which became a working language in algebraic geometry and number theory in the 1950s and began to spread to logic and computer science soon after it was created. Offering excellent use of helpful examples in Haskell, the work covers (among other things) concepts of functors, natural transformations, monads, adjoints, universality, category equivalence, and many others. The main goal is to understand the Yoneda lemma, which can be used to reverse-engineer the implementation of a function. Later chapters offer more insights into computer science, including computation with output, nondeterministic computation, and continuation passing. Topics and features: Contains rigorous mathematical arguments to support the theory Provides numerous Haskell code-implementing examples Engages with plentiful diagram chasing, with special emphasis on the design patterns for constructing a large diagram out of basic small pieces Offers insights into category theory to quantum computing and the foundation of computing discipline Serves as a preparatory course for monoidal categories and higher categories The work will be useful to undergraduate students in computer science who have enough background in college mathematics such as linear algebra and basics in Haskell polymorphic functions. Further, it will appeal to graduate students and researchers in computing disciplines who want to newly acquire serious knowledge of category theory.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared April 2, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared April 2, 2025

The readings shared in Bluesky on 2 April 2025 are Basic probability in Mathlib. ~ Rémy Degenne. #ITP #LeanProver #Mathlib #Math GOL in GOL in HOL: Verified circuits in Conway's game of life. ~ Magnu

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Faking ADTs and GADTs in languages that shouldn't have them. ~ Justin Lê. blog.jle.im/entry/faking-adts-

blog.jle.im

Faking ADTs and GADTs in Languages That Shouldn't Have Them

Haskell is the world’s best programming language, but let’s face the harsh reality that a lot of times in life you’ll have to write in other programming languages. But alas you have been fully Haskell-brained and lost all ability to program unless it is type-directed, you don’t even know how to start writing a program without imagining its shape as a type first. Well, fear not. The foundational theory behind Algebraic Data Types and Generalized Algebraic Data Types (ADTs and GADTs) are so fundamental that they’ll fit (somewhat) seamlessly into whatever language you’re forced to write. After all, if they can fit profunctor optics in Microsoft’s Java code, the sky’s the limit! This is an “April Fools” joke in the tradition of my previous one in some of these ways that we are going to twist these other languages might seem unconventional or possibly ill-advised… but also the title is definitely a lie: these languages definitely should have them! :D

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared April 1, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared April 1, 2025

The readings shared in Bluesky on 1 April 2025 are A small Prolog on the Z3 AST. ~ Philip Zucker. #Prolog #LogicProgramming #Z3 #SMT STP: Self-play LLM theorem provers with iterative conjecturing and

Haskell Weekly
@haskell_discussions@mastodon.social

[Not April Fools] Faking ADTs and GADTs in Languages That Shouldn't Have Them

blog.jle.im/entry/faking-adts-

Discussions: discu.eu/q/https://blog.jle.im

discu.eu

Faking ADTs and GADTs in Languages That Shouldn't Have Them · in Code - discu.eu

Discussions and related articles for «Faking ADTs and GADTs in Languages That Shouldn't Have Them · in Code»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

: Número de pares de elementos adyacentes iguales en una matriz. jaalonso.github.io/exercitium/

jaalonso.github.io

Número de pares de elementos adyacentes iguales en una matriz

Una matriz se puede representar mediante una lista de listas. Por ejemplo, la matriz |2 1 5| |4 3 7| se puede representar mediante la lista [[2,1,5],[4,3,7]] Definir la función numeroParesAdyacent

Haskell Weekly
@haskell_discussions@mastodon.social

Declarative UIs in a functional language - Felipe Almeida Lessa | Lambda Days 2024

youtube.com/watch?v=R51tulAtIoE

Discussions: discu.eu/q/https://www.youtube

discu.eu

Declarative UIs in a functional language - Felipe Almeida Lessa | Lambda Days 2024 - discu.eu

Discussions and related articles for «Declarative UIs in a functional language - Felipe Almeida Lessa | Lambda Days 2024»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared March 31, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 31, 2025

The readings shared in Bluesky on 31 March 2025 are Formally verifying a transformation from MLTL formulas to regular expressions. ~ Zili Wang, Katherine Kosaian, Kristin Yvonne Rozier. #ITP #Isabell

Haskell Weekly
@haskell_discussions@mastodon.social

Function Application Needs to Grow a Spine Already

thunderseethe.dev/posts/functi

Discussions: discu.eu/q/https://thunderseet

discu.eu

Function Application Needs to Grow a Spine Already · Thunderseethe's Devlog - discu.eu

Discussions and related articles for «Function Application Needs to Grow a Spine Already · Thunderseethe's Devlog»

Haskell Weekly
@haskell_discussions@mastodon.social

Introducing the Haskell Foundation Stability Working Group

blog.haskell.org/stability-wor

Discussions: discu.eu/q/https://blog.haskel

discu.eu

Introducing the Haskell Foundation Stability Working Group | The Haskell Programming Language's blog - discu.eu

Discussions and related articles for «Introducing the Haskell Foundation Stability Working Group | The Haskell Programming Language's blog»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared March 30, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 30, 2025

The readings shared in Bluesky on 30 March 2025 are Towards mechanized verification of Verilog equivalence checking. ~ Michalis Pardalos, Laura Pozzi, John Wickerson. #ITP #Coq Introducing clean, a f

DiazCarrete
@DiazCarrete@hachyderm.io

Unfolding trees breadth-first in Haskell discourse.haskell.org/t/unfold

discourse.haskell.org

Unfolding trees breadth-first in Haskell

I wrote a blog post about a fancy way of writing breadth-first walks in Haskell: Lysxia - Unfolding trees breadth-first in Haskell The code is also available as the weave library on Hackage. It was a good excuse to experiment with Backpack and multiple libraries in one package.

Haskell Weekly
@haskell_discussions@mastodon.social

Malware is harder to find when written in obscure languages like Delphi and Haskell

theregister.com/2025/03/29/mal

Discussions: discu.eu/q/https://www.theregi

discu.eu

Malware is harder to find when written in obscure languages • The Register - discu.eu

Discussions and related articles for «Malware is harder to find when written in obscure languages • The Register»

Haskell Weekly
@haskell_discussions@mastodon.social

Contributing to Copilot 4.4

github.com/Copilot-Language/co

Discussions: discu.eu/q/https://github.com/

discu.eu

Issues to address in Copilot 4.4 · Copilot-Language/copilot · Discussion #614 · GitHub - discu.eu

Discussions and related articles for «Issues to address in Copilot 4.4 · Copilot-Language/copilot · Discussion #614 · GitHub»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared March 28, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 28, 2025

The readings shared in Bluesky on 28 March 2025 are A gentle introduction to Isabelle and Isabelle/HOL. ~ Gunnar Teege. #ITP #IsabelleHOL Verified collaboration: How Lean is transforming mathematics,

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared March 27, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 27, 2025

The readings shared in Bluesky on 27 March 2025 are Formalization of optimality conditions for smooth constrained optimization problems. ~ Chenyi Li et als. #ITP #LeanProver Formalization of algorith

Haskell Weekly
@haskell_discussions@mastodon.social

[ANNOUNCE] gitlab.haskell.org outage this weekend

discourse.haskell.org/t/gitlab

Discussions: discu.eu/q/https://discourse.h

discu.eu

Gitlab.haskell.org outage this weekend - Announcements - Haskell Community - discu.eu

Discussions and related articles for «Gitlab.haskell.org outage this weekend - Announcements - Haskell Community»

Haskell Weekly
@haskell_discussions@mastodon.social

The Haskell Unfolder Episode 41: generic monoids

well-typed.com/blog/2025/03/ha

Discussions: discu.eu/q/https://well-typed.

discu.eu

The Haskell Unfolder Episode 41: generic monoids - Well-Typed: The Haskell Consultants - discu.eu

Discussions and related articles for «The Haskell Unfolder Episode 41: generic monoids - Well-Typed: The Haskell Consultants»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

: Numeración de las ternas de números naturales. jaalonso.github.io/exercitium/

jaalonso.github.io

Numeración de las ternas de números naturales

Las ternas de números naturales se pueden ordenar como sigue (0,0,0), (0,0,1),(0,1,0),(1,0,0), (0,0,2),(0,1,1),(0,2,0),(1,0,1),(1,1,0),(2,0,0), (0,0,3),(0,1,2),(0,2,1),(0,3,0),(1,0,2),(1,1

Andres Löh
@kosmikus@functional.cafe

Tonight, 2025-03-26, at 1930 UTC (still an unusual time for US/Canada) there'll be a new episode of the , and after all this time, we'll finally talk about generics! youtube.com/watch?v=db-KjKOBMe

youtube.com

The Haskell Unfolder Episode 41: generic monoids

Generic functions are a powerful tool that allows us to make more type classes derivable. In this episode, we'll look at a simple example, namely deriving Mo...

Rafaelito 🦤
@ipxfong@mastodon.sdf.org

Took a little break from trying to wrap my head around functional programming to play with 10 PRINT on the C64.

A screenshot of my laptop showing a version of the classic 10 PRINT that I've changed slightly to pick a random set of characters.
ALT text

A screenshot of my laptop showing a version of the classic 10 PRINT that I've changed slightly to pick a random set of characters.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared March 24, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 24, 2025

The readings shared in Bluesky on 24 March 2025 are Formal verification of machine learning models in Lean. ~ Matéo H. Petel. #ITP #LeanProver #MachineLearning Why Lisp syntax works. ~ Fernando Borre

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared March 23, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 23, 2025

The readings shared in Bluesky on 23 March 2025 are A review on mechanical proving and formalization of mathematical theorems. ~ Si Chen, Wensheng Yu, Guowei Dou, Qimeng Zhang. #ITP #Coq #IsabelleHOL

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

: Valores de polinomios representados con vectores. jaalonso.github.io/exercitium/

jaalonso.github.io

Valores de polinomios representados con vectores

Los polinomios se pueden representar mediante vectores usando la librería Data.Array. En primer lugar, se define el tipo de los polinomios (con coeficientes de tipo a) mediante type Polinomio a = Arra

dilawar
@dilawar@fosstodon.org

An underappreciated feature of is that Rust code found in the wild is very much likely to work and is of good quality. The crate doesn't have to be super mature!

My experience with code in the wild is much much better than JS or python code which is not suprising if you think about it. Programmers coding in
"hard" languages generally write better code? Perhaps same thing is with and ?

Haskell Weekly
@haskell_discussions@mastodon.social

GHC String Interpolation - Final Call for prototypes

discourse.haskell.org/t/ghc-st

Discussions: discu.eu/q/https://discourse.h

discu.eu

GHC String Interpolation - Final Call for prototypes - Announcements - Haskell Community - discu.eu

Discussions and related articles for «GHC String Interpolation - Final Call for prototypes - Announcements - Haskell Community»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Learn Haskell by example. ~ Phillip Hagenlocher. books.google.com/books?id=n38p

books.google.com

Learn Haskell by Example

Learn Haskell by doing Haskell projects! In this book, you’ll get practical experience writing Haskell code and applying functional programming to actual development challenges.In Learn Haskell by Example, you’ll build your Haskell skills by working through hands-on challenges and conundrums. You’ll learn to look at each project through a Haskell lens, and then solve it using features like lazy evaluation, immutable data structures, and monads. In Learn Haskell by Example you will learn how to: • Use Haskell for daily programming tasks • Effectively apply functional concepts • Avoid common beginner pitfalls of Haskell • Apply abstract concepts in the Haskell language • Debug and profile Haskell applications • Improve the performance of Haskell applications Haskell is an amazing choice for applications that need an extra guarantee of safety, such as in smart contracts, data intensive applications, and large scale distributed systems. In this book, you’ll see just how practical Haskell can be for creating programs by building your own engaging projects! Learn how to structure real-world applications, how to work with the Haskell tool chain effectively, and what to look out for when writing critical sections in the program's logic. Best of all, each project in this book is fully extensible and customizable so you can keep tinkering with your favorites! About the technology Programmers spend a lot of time debugging and refactoring code, reading comments and documentation, and trying to make sense out of complex designs. Haskell, a powerful, beautiful, and challenging functional programming language, promises a different path. By focusing your attention on simple functions, clearly-defined behaviors, and the right high-level abstractions, Haskell disallows the dangerous behaviors that usually lead to bugs and crashes. About the book Learn Haskell by Example teaches you to build applications in Haskell by designing and coding fun and engaging projects. In this easy-to-follow guide, you’ll create a domain specific language for music, an image processing library, and more! You’ll learn Haskell from the ground-up with a focus on important concepts like function design, composition, and data immutability. Each project gives you a new insight into how to think in Haskell and helps you understand why many Haskell developers say they will never use another language again. What's inside • Use Haskell for daily programming tasks • Purely functional programming • Avoid common Haskell pitfalls About the reader For readers who know how to program in an object-oriented language. About the author Philipp Hagenlocher is a full time Haskell developer, and the creator of the beloved Haskell for Imperative Programmers YouTube course. The technical editor on this book was Alexander Vershilov. Table of Contents 1 Introduction 2 Ancient secret keeping on modern machines 3 Every line counts 4 Line numbering tool 5 Words and graphs 6 Solving the ladder game 7 Working with CSV files 8 A tool for CSV 9 Quick checks and random tests 10 Digital music box 11 Programming musical compositions 12 Parsing pixel data 13 Parallel image processing 14 Files and exceptions 15 Transformers for synchronizing 16 JSON and SQL 17 APIs using Servant Appendix A The Haskell Toolchain Appendix B Lazy evaluation

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared March 21, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 21, 2025

The readings shared in Bluesky on 21 March 2025 are Case study: Verified Vampire proofs in the LambdaPi-calculus modulo. ~ Anja Petković Komel, Michael Rawson, Martin Suad. #ATP #Vampire #Dedukti A h

Haskell Weekly
@haskell_discussions@mastodon.social

US to limit Canadian access to built on border Haskell Free Library & Opera House

bostonglobe.com/2025/03/20/met

Discussions: discu.eu/q/https://www.bostong

discu.eu

US to limit Canadian access to cross-border library where Kristi Noem taunted hosts - discu.eu

Discussions and related articles for «US to limit Canadian access to cross-border library where Kristi Noem taunted hosts»

Haskell Weekly
@haskell_discussions@mastodon.social

[Well-Typed] GHC activities report: December 2024-February 2025

well-typed.com/blog/2025/03/gh

Discussions: discu.eu/q/https://www.well-ty

discu.eu

GHC activities report: December 2024–February 2025 - Well-Typed: The Haskell Consultants - discu.eu

Discussions and related articles for «GHC activities report: December 2024–February 2025 - Well-Typed: The Haskell Consultants»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared March 20, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 19, 2025

The readings shared in Bluesky on 19 March 2025 are #Exercitium: Máximos locales. #Haskell #ProgramaciónFuncional #Matemáticas Demostraciones de "s ∩ (t ∪ u) ⊆ (s ∩ t) ∪ (s ∩ u)" con Lean4 y con Isab

Haskell Weekly
@haskell_discussions@mastodon.social

haskell-dev-env - An opinionated pre-built Dev Container for Haskell

github.com/marijnvanwezel/hask

Discussions: discu.eu/q/https://github.com/

discu.eu

GitHub - marijnvanwezel/haskell-dev-env: An opinionated pre-built Dev Container for Haskell (which includes HLS, Cabal, Stack, a debugger, local Hoogle and useful extensions). - discu.eu

Discussions and related articles for «GitHub - marijnvanwezel/haskell-dev-env: An opinionated pre-built Dev Container for Haskell (which includes HLS, Cabal, Stack, a debugger, local Hoogle and useful extensions).»

Haskell Weekly
@haskell_discussions@mastodon.social

Open Source at Bellroy: Supporting Old GHC Versions

exploring-better-ways.bellroy.

Discussions: discu.eu/q/https://exploring-b

discu.eu

Open Source at Bellroy: Supporting Old GHC Versions - discu.eu

Discussions and related articles for «Open Source at Bellroy: Supporting Old GHC Versions»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared March 19, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 19, 2025

The readings shared in Bluesky on 19 March 2025 are A trickier lower bound proof. ~ Lawrence Paulson. #ITP #IsabelleHOL #Math Can LLMs enable verification in mainstream programming? ~ Aleksandr Shefe

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared March 18, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 18, 2025

The readings shared in Bluesky on 18 March 2025 are Lessons learned with the Z3 SAT/SMT solver. ~ John D. Cook. #SMT #Z3 Teaching logic programming: a review. ~ Serhiy O. Semerikov, Iryna S. Mintii,

Haskell Weekly
@haskell_discussions@mastodon.social

Haskell debugging in Neovim with breakpoints is giving error

reddit.com/r/neovim/comments/1

Discussions: discu.eu/q/https://www.reddit.

discu.eu

Haskell debugging in Neovim with breakpoints is giving error - discu.eu

Discussions and related articles for «Haskell debugging in Neovim with breakpoints is giving error»

Monoka
@GerryT@mastodon.social

Share of programming languages used by / applications (2025-03-16):

28%
21%
20%
17%
06% ++
06%
04% Other:

63% use GTK4 (90% of them use ), while still 37% use GTK3

Method: Source [1] lists 543 awesome (3/4) applications and their

[1] github.com/valpackett/awesome-

@GTK @gnome

github.com

GitHub - valpackett/awesome-gtk: List of awesome GTK (3/4) applications

List of awesome GTK (3/4) applications. Contribute to valpackett/awesome-gtk development by creating an account on GitHub.

Monoka
@GerryT@mastodon.social

Share of programming languages used by / applications (2025-03-16):

28%
21%
20%
17%
06% ++
06%
04% Other:

63% use GTK4 (90% of them use ), while still 37% use GTK3

Method: Source [1] lists 543 awesome (3/4) applications and their

[1] github.com/valpackett/awesome-

@GTK @gnome

github.com

GitHub - valpackett/awesome-gtk: List of awesome GTK (3/4) applications

List of awesome GTK (3/4) applications. Contribute to valpackett/awesome-gtk development by creating an account on GitHub.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared March 15, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 15, 2025

The readings shared in Bluesky on 15 March 2025 are Revisiting an early critique of formal verification. ~ Lawrence Paulson. #ITP #Math #FormalVerification A proof of the Schröder-Bernstein theorem i

Haskell Weekly
@haskell_discussions@mastodon.social

[ANN] First release candidate for Stack 3.5.1

github.com/commercialhaskell/s

Discussions: discu.eu/q/https://github.com/

discu.eu

Release rc/v3.5.0.1 (release candidate) · commercialhaskell/stack · GitHub - discu.eu

Discussions and related articles for «Release rc/v3.5.0.1 (release candidate) · commercialhaskell/stack · GitHub»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

: Primos consecutivos con media capicúa. jaalonso.github.io/exercitium/

jaalonso.github.io

Primos consecutivos con media capicúa

Definir la función primosConsecutivosConMediaCapicua :: [(Int,Int,Int)] formada por las ternas (x,y,z) tales que x e y son primos consecutivos cuya media, z, es capicúa. Por ejemplo, λ> take 5 primo

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared March 14, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 14, 2025

The readings shared in Bluesky on 14 March 2025 are La théorie des types, de Russell aux assistans à la demostration. ~ Thierry Coquand. #TypeTheory #ITP #Logic #Math Local look-ahead guidance via ve

Haskell Weekly
@haskell_discussions@mastodon.social

Aztecs v0.10: A modular game-engine and ECS for Haskell (now with a simpler design featuring applicative queries and monadic systems)

github.com/aztecs-hs/aztecs

Discussions: discu.eu/q/https://github.com/

discu.eu

GitHub - aztecs-hs/aztecs: A modular game engine and ECS for Haskell - discu.eu

Discussions and related articles for «GitHub - aztecs-hs/aztecs: A modular game engine and ECS for Haskell»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared March 13, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 13, 2025

The readings shared in Bluesky on 13 March 2025 are Course notes for "Formalising Mathematics 2025". ~ Bhavik Mehta et als. #ITP #LeanProver #Math LeanAgent: Lifelong learning for formal theorem prov

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared March 12, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 12, 2025

The readings shared in Bluesky on 12 March 2025 are A formal proof of the irrationality of ζ(3) in Lean 4. ~ Junqi Liu, Jujian Zhang, Lihong Zhi. #ITP #LeanProver #Math #Exercitium: La bandera tricol

Haskell Weekly
@haskell_discussions@mastodon.social

The Haskell Unfolder Episode 40: understanding through a model

youtube.com/watch?index=40&lis

Discussions: discu.eu/q/https://www.youtube

discu.eu

The Haskell Unfolder Episode 40: understanding through a model - discu.eu

Discussions and related articles for «The Haskell Unfolder Episode 40: understanding through a model»

Hacker News
@h4ckernews@mastodon.social

The State of Coherence in the Land of Type Classes

programming-journal.org/2025/1

programming-journal.org

On the State of Coherence in the Land of Type Classes

Type classes are a popular tool for implementing generic algorithms and data structures without loss of efficiency, bridging the gap between parametric and ad-hoc polymorphism. Since their initial development in Haskell, they now feature prominently in numerous other industry-ready programming la...

Hacker News
@h4ckernews@mastodon.social

The State of Coherence in the Land of Type Classes

programming-journal.org/2025/1

programming-journal.org

On the State of Coherence in the Land of Type Classes

Type classes are a popular tool for implementing generic algorithms and data structures without loss of efficiency, bridging the gap between parametric and ad-hoc polymorphism. Since their initial development in Haskell, they now feature prominently in numerous other industry-ready programming la...

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared March 11, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 11, 2025

The readings shared in Bluesky on 11 March 2025 are Extrinsic termination proofs for well-founded recursion in Lean. ~ Joachim Breitner. #ITP #LeanProver Knuth Bendix solver on Z3 AST. ~ Philip Zucke

Andres Löh
@kosmikus@functional.cafe

Tomorrow, 2025-03-12, at 1930 UTC (note: one hour later than usual in Canada / US due to asynchronous DST shifts), there'll be a new episode of the , titled "understanding through a model". We'll talk about QuickCheck and convolutions ...

youtube.com/watch?v=0QTt2W7CVn

youtube.com

The Haskell Unfolder Episode 40: understanding through a model

QuickCheck is useful for more than just testing. Comparing the behaviour of a system to a model can be used to check if a system under construction is worki...

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared March 10, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 10, 2025

The readings shared in Bluesky on 10 March 2025 are The burden of proof: Automated tooling for rapid iteration on large mechanised proofs. ~ Chengsong Tan, Alastair F. Donaldson, Jonathan Julián Huer

Haskell Weekly
@haskell_discussions@mastodon.social

Stage Fright Peeled Away: Writing the 'peel' Function with Template Haskell

free.cofree.io/2025/03/10/temp

Discussions: discu.eu/q/https://free.cofree

discu.eu

Stage Fright Peeled Away: Writing the 'peel' Function with Template Haskell - discu.eu

Discussions and related articles for «Stage Fright Peeled Away: Writing the 'peel' Function with Template Haskell»

洪 民憙 (Hong Minhee) :nonbinary:
@hongminhee@hollo.social

Just what the internet needed: another attempt to explain ! 🙄 But this time I'm comparing and approaches to show why make all the difference. Turns out those JavaScript Promise analogies only tell half the story…

https://hackers.pub/@hongminhee/2025/monads

hackers.pub

Monads: Beyond Simple Analogies—Reflections on Functional Programming Paradigms

While exploring functional programming languages, I've been reflecting on how different communities approach similar concepts. One pattern that seems particularly fascinating is how Haskell and OCaml communities differ in their embrace of monads as an abstraction tool. The Elegant Power of Monads in Haskell It's common to hear monads explained through analogies to concepts like JavaScript's Promise or jQuery chains. While these comparisons provide an entry point, they might miss what makes monads truly beautiful and powerful in Haskell's ecosystem. The real strength appears to lie in the Monad typeclass itself. This elegant abstraction allows for creating generic functions and types that work with any type that shares the monad property. This seems to offer a profound unification of concepts that might initially appear unrelated: You can write code once that works across many contexts (Maybe, [], IO, State, etc.) Generic functions like sequence, mapM, and others become available across all monadic types The same patterns and mental models apply consistently across different computational contexts For example, a simple conditional function like this works beautifully in any monadic context: whenM :: Monad m => m Bool -> m () -> m () whenM condition action = do result <- condition if result then action else return () Whether dealing with potentially missing values, asynchronous operations, or state transformations, the same function can be employed without modification. There's something genuinely satisfying about this level of abstraction and reuse. OCaml's Different Approach Interestingly, the OCaml community seems less enthusiastic about monads as a primary abstraction tool. This might stem from several factors related to language design: Structural Differences OCaml lacks built-in typeclass support, relying instead on its module system and functors. While powerful in its own right, this approach might not make monad abstractions feel as natural or convenient: (* OCaml monad implementation requires more boilerplate *) module type MONAD = sig type 'a t val return : 'a -> 'a t val bind : 'a t -> ('a -> 'b t) -> 'b t end module OptionMonad : MONAD with type 'a t = 'a option = struct type 'a t = 'a option let return x = Some x let bind m f = match m with | None -> None | Some x -> f x end OCaml also doesn't offer syntactic sugar like Haskell's do notation, which makes monadic code in Haskell considerably more readable and expressive: -- Haskell's elegant do notation userInfo = do name <- getLine age <- readLn return (name, age) Compared to the more verbose OCaml equivalent: let user_info = get_line >>= fun name -> read_ln >>= fun age -> return (name, age) The readability difference becomes even more pronounced in more complex monadic operations. Philosophical Differences Beyond syntax, the languages differ in their fundamental approach to effects: Haskell is purely functional, making monads essential for managing effects in a principled way OCaml permits direct side effects, often making monadic abstractions optional This allows OCaml programmers to write more direct code when appropriate: (* Direct style in OCaml *) let get_user_info () = print_string "Name: "; let name = read_line () in print_string "Age: "; let age = int_of_string (read_line ()) in (name, age) OCaml's approach might favor pragmatism and directness in many cases, with programmers often preferring: Direct use of option and result types Module-level abstractions through functors Continuation-passing style when needed While this directness can be beneficial for immediate readability, it might come at the cost of some of the elegant uniformity that Haskell's monadic approach provides. Reflections on Language Design These differences highlight how programming language design shapes the idioms and patterns that emerge within their communities. Neither approach is objectively superior—they represent different philosophies about abstraction, explicitness, and the role of the type system. Haskell's approach encourages a high level of abstraction and consistency across different computational contexts, which can feel particularly satisfying when working with complex, interconnected systems. There's something intellectually pleasing about solving a problem once and having that solution generalize across many contexts. OCaml often favors more direct solutions that might be easier to reason about locally, though potentially at the cost of less uniformity across the codebase. This approach has its own virtues, particularly for systems where immediate comprehensibility is paramount. After working with both paradigms, I find myself drawn to the consistent abstractions that Haskell's approach provides, while still appreciating the pragmatic clarity that OCaml can offer in certain situations. The typeclasses and syntactic support in Haskell seem to unlock a particularly elegant way of structuring code that, while perhaps requiring a steeper initial learning curve, offers a uniquely satisfying programming experience. What patterns have you noticed in how different programming language communities approach similar problems? And have you found yourself drawn to the elegant abstractions of Haskell or the pragmatic approach of OCaml?

洪 民憙 (Hong Minhee)
@hongminhee@hackers.pub

While exploring functional programming languages, I've been reflecting on how different communities approach similar concepts. One pattern that seems particularly fascinating is how Haskell and OCaml communities differ in their embrace of monads as an abstraction tool.

The Elegant Power of Monads in Haskell

It's common to hear monads explained through analogies to concepts like JavaScript's Promise or jQuery chains. While these comparisons provide an entry point, they might miss what makes monads truly beautiful and powerful in Haskell's ecosystem.

The real strength appears to lie in the Monad typeclass itself. This elegant abstraction allows for creating generic functions and types that work with any type that shares the monad property. This seems to offer a profound unification of concepts that might initially appear unrelated:

  • You can write code once that works across many contexts (Maybe, [], IO, State, etc.)
  • Generic functions like sequence, mapM, and others become available across all monadic types
  • The same patterns and mental models apply consistently across different computational contexts

For example, a simple conditional function like this works beautifully in any monadic context:

whenM :: Monad m => m Bool -> m () -> m ()
whenM condition action = do
  result <- condition
  if result then action else return ()

Whether dealing with potentially missing values, asynchronous operations, or state transformations, the same function can be employed without modification. There's something genuinely satisfying about this level of abstraction and reuse.

OCaml's Different Approach

Interestingly, the OCaml community seems less enthusiastic about monads as a primary abstraction tool. This might stem from several factors related to language design:

Structural Differences

OCaml lacks built-in typeclass support, relying instead on its module system and functors. While powerful in its own right, this approach might not make monad abstractions feel as natural or convenient:

(* OCaml monad implementation requires more boilerplate *)
module type MONAD = sig
  type 'a t
  val return : 'a -> 'a t
  val bind : 'a t -> ('a -> 'b t) -> 'b t
end

module OptionMonad : MONAD with type 'a t = 'a option = struct
  type 'a t = 'a option
  let return x = Some x
  let bind m f = match m with
    | None -> None
    | Some x -> f x
end

OCaml also doesn't offer syntactic sugar like Haskell's do notation, which makes monadic code in Haskell considerably more readable and expressive:

-- Haskell's elegant do notation
userInfo = do
  name <- getLine
  age <- readLn
  return (name, age)

Compared to the more verbose OCaml equivalent:

let user_info =
  get_line >>= fun name ->
  read_ln >>= fun age ->
  return (name, age)

The readability difference becomes even more pronounced in more complex monadic operations.

Philosophical Differences

Beyond syntax, the languages differ in their fundamental approach to effects:

  • Haskell is purely functional, making monads essential for managing effects in a principled way
  • OCaml permits direct side effects, often making monadic abstractions optional

This allows OCaml programmers to write more direct code when appropriate:

(* Direct style in OCaml *)
let get_user_info () =
  print_string "Name: ";
  let name = read_line () in
  print_string "Age: ";
  let age = int_of_string (read_line ()) in
  (name, age)

OCaml's approach might favor pragmatism and directness in many cases, with programmers often preferring:

  • Direct use of option and result types
  • Module-level abstractions through functors
  • Continuation-passing style when needed

While this directness can be beneficial for immediate readability, it might come at the cost of some of the elegant uniformity that Haskell's monadic approach provides.

Reflections on Language Design

These differences highlight how programming language design shapes the idioms and patterns that emerge within their communities. Neither approach is objectively superior—they represent different philosophies about abstraction, explicitness, and the role of the type system.

Haskell's approach encourages a high level of abstraction and consistency across different computational contexts, which can feel particularly satisfying when working with complex, interconnected systems. There's something intellectually pleasing about solving a problem once and having that solution generalize across many contexts.

OCaml often favors more direct solutions that might be easier to reason about locally, though potentially at the cost of less uniformity across the codebase. This approach has its own virtues, particularly for systems where immediate comprehensibility is paramount.

After working with both paradigms, I find myself drawn to the consistent abstractions that Haskell's approach provides, while still appreciating the pragmatic clarity that OCaml can offer in certain situations. The typeclasses and syntactic support in Haskell seem to unlock a particularly elegant way of structuring code that, while perhaps requiring a steeper initial learning curve, offers a uniquely satisfying programming experience.

What patterns have you noticed in how different programming language communities approach similar problems? And have you found yourself drawn to the elegant abstractions of Haskell or the pragmatic approach of OCaml?

洪 民憙 (Hong Minhee) :nonbinary:
@hongminhee@hollo.social

Just what the internet needed: another attempt to explain ! 🙄 But this time I'm comparing and approaches to show why make all the difference. Turns out those JavaScript Promise analogies only tell half the story…

https://hackers.pub/@hongminhee/2025/monads

hackers.pub

Monads: Beyond Simple Analogies—Reflections on Functional Programming Paradigms

While exploring functional programming languages, I've been reflecting on how different communities approach similar concepts. One pattern that seems particularly fascinating is how Haskell and OCaml communities differ in their embrace of monads as an abstraction tool. The Elegant Power of Monads in Haskell It's common to hear monads explained through analogies to concepts like JavaScript's Promise or jQuery chains. While these comparisons provide an entry point, they might miss what makes monads truly beautiful and powerful in Haskell's ecosystem. The real strength appears to lie in the Monad typeclass itself. This elegant abstraction allows for creating generic functions and types that work with any type that shares the monad property. This seems to offer a profound unification of concepts that might initially appear unrelated: You can write code once that works across many contexts (Maybe, [], IO, State, etc.) Generic functions like sequence, mapM, and others become available across all monadic types The same patterns and mental models apply consistently across different computational contexts For example, a simple conditional function like this works beautifully in any monadic context: whenM :: Monad m => m Bool -> m () -> m () whenM condition action = do result <- condition if result then action else return () Whether dealing with potentially missing values, asynchronous operations, or state transformations, the same function can be employed without modification. There's something genuinely satisfying about this level of abstraction and reuse. OCaml's Different Approach Interestingly, the OCaml community seems less enthusiastic about monads as a primary abstraction tool. This might stem from several factors related to language design: Structural Differences OCaml lacks built-in typeclass support, relying instead on its module system and functors. While powerful in its own right, this approach might not make monad abstractions feel as natural or convenient: (* OCaml monad implementation requires more boilerplate *) module type MONAD = sig type 'a t val return : 'a -> 'a t val bind : 'a t -> ('a -> 'b t) -> 'b t end module OptionMonad : MONAD with type 'a t = 'a option = struct type 'a t = 'a option let return x = Some x let bind m f = match m with | None -> None | Some x -> f x end OCaml also doesn't offer syntactic sugar like Haskell's do notation, which makes monadic code in Haskell considerably more readable and expressive: -- Haskell's elegant do notation userInfo = do name <- getLine age <- readLn return (name, age) Compared to the more verbose OCaml equivalent: let user_info = get_line >>= fun name -> read_ln >>= fun age -> return (name, age) The readability difference becomes even more pronounced in more complex monadic operations. Philosophical Differences Beyond syntax, the languages differ in their fundamental approach to effects: Haskell is purely functional, making monads essential for managing effects in a principled way OCaml permits direct side effects, often making monadic abstractions optional This allows OCaml programmers to write more direct code when appropriate: (* Direct style in OCaml *) let get_user_info () = print_string "Name: "; let name = read_line () in print_string "Age: "; let age = int_of_string (read_line ()) in (name, age) OCaml's approach might favor pragmatism and directness in many cases, with programmers often preferring: Direct use of option and result types Module-level abstractions through functors Continuation-passing style when needed While this directness can be beneficial for immediate readability, it might come at the cost of some of the elegant uniformity that Haskell's monadic approach provides. Reflections on Language Design These differences highlight how programming language design shapes the idioms and patterns that emerge within their communities. Neither approach is objectively superior—they represent different philosophies about abstraction, explicitness, and the role of the type system. Haskell's approach encourages a high level of abstraction and consistency across different computational contexts, which can feel particularly satisfying when working with complex, interconnected systems. There's something intellectually pleasing about solving a problem once and having that solution generalize across many contexts. OCaml often favors more direct solutions that might be easier to reason about locally, though potentially at the cost of less uniformity across the codebase. This approach has its own virtues, particularly for systems where immediate comprehensibility is paramount. After working with both paradigms, I find myself drawn to the consistent abstractions that Haskell's approach provides, while still appreciating the pragmatic clarity that OCaml can offer in certain situations. The typeclasses and syntactic support in Haskell seem to unlock a particularly elegant way of structuring code that, while perhaps requiring a steeper initial learning curve, offers a uniquely satisfying programming experience. What patterns have you noticed in how different programming language communities approach similar problems? And have you found yourself drawn to the elegant abstractions of Haskell or the pragmatic approach of OCaml?

洪 民憙 (Hong Minhee)
@hongminhee@hackers.pub

While exploring functional programming languages, I've been reflecting on how different communities approach similar concepts. One pattern that seems particularly fascinating is how Haskell and OCaml communities differ in their embrace of monads as an abstraction tool.

The Elegant Power of Monads in Haskell

It's common to hear monads explained through analogies to concepts like JavaScript's Promise or jQuery chains. While these comparisons provide an entry point, they might miss what makes monads truly beautiful and powerful in Haskell's ecosystem.

The real strength appears to lie in the Monad typeclass itself. This elegant abstraction allows for creating generic functions and types that work with any type that shares the monad property. This seems to offer a profound unification of concepts that might initially appear unrelated:

  • You can write code once that works across many contexts (Maybe, [], IO, State, etc.)
  • Generic functions like sequence, mapM, and others become available across all monadic types
  • The same patterns and mental models apply consistently across different computational contexts

For example, a simple conditional function like this works beautifully in any monadic context:

whenM :: Monad m => m Bool -> m () -> m ()
whenM condition action = do
  result <- condition
  if result then action else return ()

Whether dealing with potentially missing values, asynchronous operations, or state transformations, the same function can be employed without modification. There's something genuinely satisfying about this level of abstraction and reuse.

OCaml's Different Approach

Interestingly, the OCaml community seems less enthusiastic about monads as a primary abstraction tool. This might stem from several factors related to language design:

Structural Differences

OCaml lacks built-in typeclass support, relying instead on its module system and functors. While powerful in its own right, this approach might not make monad abstractions feel as natural or convenient:

(* OCaml monad implementation requires more boilerplate *)
module type MONAD = sig
  type 'a t
  val return : 'a -> 'a t
  val bind : 'a t -> ('a -> 'b t) -> 'b t
end

module OptionMonad : MONAD with type 'a t = 'a option = struct
  type 'a t = 'a option
  let return x = Some x
  let bind m f = match m with
    | None -> None
    | Some x -> f x
end

OCaml also doesn't offer syntactic sugar like Haskell's do notation, which makes monadic code in Haskell considerably more readable and expressive:

-- Haskell's elegant do notation
userInfo = do
  name <- getLine
  age <- readLn
  return (name, age)

Compared to the more verbose OCaml equivalent:

let user_info =
  get_line >>= fun name ->
  read_ln >>= fun age ->
  return (name, age)

The readability difference becomes even more pronounced in more complex monadic operations.

Philosophical Differences

Beyond syntax, the languages differ in their fundamental approach to effects:

  • Haskell is purely functional, making monads essential for managing effects in a principled way
  • OCaml permits direct side effects, often making monadic abstractions optional

This allows OCaml programmers to write more direct code when appropriate:

(* Direct style in OCaml *)
let get_user_info () =
  print_string "Name: ";
  let name = read_line () in
  print_string "Age: ";
  let age = int_of_string (read_line ()) in
  (name, age)

OCaml's approach might favor pragmatism and directness in many cases, with programmers often preferring:

  • Direct use of option and result types
  • Module-level abstractions through functors
  • Continuation-passing style when needed

While this directness can be beneficial for immediate readability, it might come at the cost of some of the elegant uniformity that Haskell's monadic approach provides.

Reflections on Language Design

These differences highlight how programming language design shapes the idioms and patterns that emerge within their communities. Neither approach is objectively superior—they represent different philosophies about abstraction, explicitness, and the role of the type system.

Haskell's approach encourages a high level of abstraction and consistency across different computational contexts, which can feel particularly satisfying when working with complex, interconnected systems. There's something intellectually pleasing about solving a problem once and having that solution generalize across many contexts.

OCaml often favors more direct solutions that might be easier to reason about locally, though potentially at the cost of less uniformity across the codebase. This approach has its own virtues, particularly for systems where immediate comprehensibility is paramount.

After working with both paradigms, I find myself drawn to the consistent abstractions that Haskell's approach provides, while still appreciating the pragmatic clarity that OCaml can offer in certain situations. The typeclasses and syntactic support in Haskell seem to unlock a particularly elegant way of structuring code that, while perhaps requiring a steeper initial learning curve, offers a uniquely satisfying programming experience.

What patterns have you noticed in how different programming language communities approach similar problems? And have you found yourself drawn to the elegant abstractions of Haskell or the pragmatic approach of OCaml?

洪 民憙 (Hong Minhee) :nonbinary:
@hongminhee@hollo.social · Reply to 洪 民憙 (Hong Minhee) :nonbinary:

またまた世界にモナドの解説が増えてしまいました。😅 今回はHaskellとOCamlのアプローチを比較して、型クラスがどれだけ重要な違いを齎すかに就いて書いてみました。JavaScriptのPromiseと比べる譬えは半分しか真実を語っていないんですよね…

https://hackers.pub/@hongminhee/2025/monads

hackers.pub

Monads: Beyond Simple Analogies—Reflections on Functional Programming Paradigms

While exploring functional programming languages, I've been reflecting on how different communities approach similar concepts. One pattern that seems particularly fascinating is how Haskell and OCaml communities differ in their embrace of monads as an abstraction tool. The Elegant Power of Monads in Haskell It's common to hear monads explained through analogies to concepts like JavaScript's Promise or jQuery chains. While these comparisons provide an entry point, they might miss what makes monads truly beautiful and powerful in Haskell's ecosystem. The real strength appears to lie in the Monad typeclass itself. This elegant abstraction allows for creating generic functions and types that work with any type that shares the monad property. This seems to offer a profound unification of concepts that might initially appear unrelated: You can write code once that works across many contexts (Maybe, [], IO, State, etc.) Generic functions like sequence, mapM, and others become available across all monadic types The same patterns and mental models apply consistently across different computational contexts For example, a simple conditional function like this works beautifully in any monadic context: whenM :: Monad m => m Bool -> m () -> m () whenM condition action = do result <- condition if result then action else return () Whether dealing with potentially missing values, asynchronous operations, or state transformations, the same function can be employed without modification. There's something genuinely satisfying about this level of abstraction and reuse. OCaml's Different Approach Interestingly, the OCaml community seems less enthusiastic about monads as a primary abstraction tool. This might stem from several factors related to language design: Structural Differences OCaml lacks built-in typeclass support, relying instead on its module system and functors. While powerful in its own right, this approach might not make monad abstractions feel as natural or convenient: (* OCaml monad implementation requires more boilerplate *) module type MONAD = sig type 'a t val return : 'a -> 'a t val bind : 'a t -> ('a -> 'b t) -> 'b t end module OptionMonad : MONAD with type 'a t = 'a option = struct type 'a t = 'a option let return x = Some x let bind m f = match m with | None -> None | Some x -> f x end OCaml also doesn't offer syntactic sugar like Haskell's do notation, which makes monadic code in Haskell considerably more readable and expressive: -- Haskell's elegant do notation userInfo = do name <- getLine age <- readLn return (name, age) Compared to the more verbose OCaml equivalent: let user_info = get_line >>= fun name -> read_ln >>= fun age -> return (name, age) The readability difference becomes even more pronounced in more complex monadic operations. Philosophical Differences Beyond syntax, the languages differ in their fundamental approach to effects: Haskell is purely functional, making monads essential for managing effects in a principled way OCaml permits direct side effects, often making monadic abstractions optional This allows OCaml programmers to write more direct code when appropriate: (* Direct style in OCaml *) let get_user_info () = print_string "Name: "; let name = read_line () in print_string "Age: "; let age = int_of_string (read_line ()) in (name, age) OCaml's approach might favor pragmatism and directness in many cases, with programmers often preferring: Direct use of option and result types Module-level abstractions through functors Continuation-passing style when needed While this directness can be beneficial for immediate readability, it might come at the cost of some of the elegant uniformity that Haskell's monadic approach provides. Reflections on Language Design These differences highlight how programming language design shapes the idioms and patterns that emerge within their communities. Neither approach is objectively superior—they represent different philosophies about abstraction, explicitness, and the role of the type system. Haskell's approach encourages a high level of abstraction and consistency across different computational contexts, which can feel particularly satisfying when working with complex, interconnected systems. There's something intellectually pleasing about solving a problem once and having that solution generalize across many contexts. OCaml often favors more direct solutions that might be easier to reason about locally, though potentially at the cost of less uniformity across the codebase. This approach has its own virtues, particularly for systems where immediate comprehensibility is paramount. After working with both paradigms, I find myself drawn to the consistent abstractions that Haskell's approach provides, while still appreciating the pragmatic clarity that OCaml can offer in certain situations. The typeclasses and syntactic support in Haskell seem to unlock a particularly elegant way of structuring code that, while perhaps requiring a steeper initial learning curve, offers a uniquely satisfying programming experience. What patterns have you noticed in how different programming language communities approach similar problems? And have you found yourself drawn to the elegant abstractions of Haskell or the pragmatic approach of OCaml?

洪 民憙 (Hong Minhee)
@hongminhee@hackers.pub

While exploring functional programming languages, I've been reflecting on how different communities approach similar concepts. One pattern that seems particularly fascinating is how Haskell and OCaml communities differ in their embrace of monads as an abstraction tool.

The Elegant Power of Monads in Haskell

It's common to hear monads explained through analogies to concepts like JavaScript's Promise or jQuery chains. While these comparisons provide an entry point, they might miss what makes monads truly beautiful and powerful in Haskell's ecosystem.

The real strength appears to lie in the Monad typeclass itself. This elegant abstraction allows for creating generic functions and types that work with any type that shares the monad property. This seems to offer a profound unification of concepts that might initially appear unrelated:

  • You can write code once that works across many contexts (Maybe, [], IO, State, etc.)
  • Generic functions like sequence, mapM, and others become available across all monadic types
  • The same patterns and mental models apply consistently across different computational contexts

For example, a simple conditional function like this works beautifully in any monadic context:

whenM :: Monad m => m Bool -> m () -> m ()
whenM condition action = do
  result <- condition
  if result then action else return ()

Whether dealing with potentially missing values, asynchronous operations, or state transformations, the same function can be employed without modification. There's something genuinely satisfying about this level of abstraction and reuse.

OCaml's Different Approach

Interestingly, the OCaml community seems less enthusiastic about monads as a primary abstraction tool. This might stem from several factors related to language design:

Structural Differences

OCaml lacks built-in typeclass support, relying instead on its module system and functors. While powerful in its own right, this approach might not make monad abstractions feel as natural or convenient:

(* OCaml monad implementation requires more boilerplate *)
module type MONAD = sig
  type 'a t
  val return : 'a -> 'a t
  val bind : 'a t -> ('a -> 'b t) -> 'b t
end

module OptionMonad : MONAD with type 'a t = 'a option = struct
  type 'a t = 'a option
  let return x = Some x
  let bind m f = match m with
    | None -> None
    | Some x -> f x
end

OCaml also doesn't offer syntactic sugar like Haskell's do notation, which makes monadic code in Haskell considerably more readable and expressive:

-- Haskell's elegant do notation
userInfo = do
  name <- getLine
  age <- readLn
  return (name, age)

Compared to the more verbose OCaml equivalent:

let user_info =
  get_line >>= fun name ->
  read_ln >>= fun age ->
  return (name, age)

The readability difference becomes even more pronounced in more complex monadic operations.

Philosophical Differences

Beyond syntax, the languages differ in their fundamental approach to effects:

  • Haskell is purely functional, making monads essential for managing effects in a principled way
  • OCaml permits direct side effects, often making monadic abstractions optional

This allows OCaml programmers to write more direct code when appropriate:

(* Direct style in OCaml *)
let get_user_info () =
  print_string "Name: ";
  let name = read_line () in
  print_string "Age: ";
  let age = int_of_string (read_line ()) in
  (name, age)

OCaml's approach might favor pragmatism and directness in many cases, with programmers often preferring:

  • Direct use of option and result types
  • Module-level abstractions through functors
  • Continuation-passing style when needed

While this directness can be beneficial for immediate readability, it might come at the cost of some of the elegant uniformity that Haskell's monadic approach provides.

Reflections on Language Design

These differences highlight how programming language design shapes the idioms and patterns that emerge within their communities. Neither approach is objectively superior—they represent different philosophies about abstraction, explicitness, and the role of the type system.

Haskell's approach encourages a high level of abstraction and consistency across different computational contexts, which can feel particularly satisfying when working with complex, interconnected systems. There's something intellectually pleasing about solving a problem once and having that solution generalize across many contexts.

OCaml often favors more direct solutions that might be easier to reason about locally, though potentially at the cost of less uniformity across the codebase. This approach has its own virtues, particularly for systems where immediate comprehensibility is paramount.

After working with both paradigms, I find myself drawn to the consistent abstractions that Haskell's approach provides, while still appreciating the pragmatic clarity that OCaml can offer in certain situations. The typeclasses and syntactic support in Haskell seem to unlock a particularly elegant way of structuring code that, while perhaps requiring a steeper initial learning curve, offers a uniquely satisfying programming experience.

What patterns have you noticed in how different programming language communities approach similar problems? And have you found yourself drawn to the elegant abstractions of Haskell or the pragmatic approach of OCaml?

洪 民憙 (Hong Minhee) :nonbinary:
@hongminhee@hollo.social · Reply to 洪 民憙 (Hong Minhee) :nonbinary:

またまた世界にモナドの解説が増えてしまいました。😅 今回はHaskellとOCamlのアプローチを比較して、型クラスがどれだけ重要な違いを齎すかに就いて書いてみました。JavaScriptのPromiseと比べる譬えは半分しか真実を語っていないんですよね…

https://hackers.pub/@hongminhee/2025/monads

hackers.pub

Monads: Beyond Simple Analogies—Reflections on Functional Programming Paradigms

While exploring functional programming languages, I've been reflecting on how different communities approach similar concepts. One pattern that seems particularly fascinating is how Haskell and OCaml communities differ in their embrace of monads as an abstraction tool. The Elegant Power of Monads in Haskell It's common to hear monads explained through analogies to concepts like JavaScript's Promise or jQuery chains. While these comparisons provide an entry point, they might miss what makes monads truly beautiful and powerful in Haskell's ecosystem. The real strength appears to lie in the Monad typeclass itself. This elegant abstraction allows for creating generic functions and types that work with any type that shares the monad property. This seems to offer a profound unification of concepts that might initially appear unrelated: You can write code once that works across many contexts (Maybe, [], IO, State, etc.) Generic functions like sequence, mapM, and others become available across all monadic types The same patterns and mental models apply consistently across different computational contexts For example, a simple conditional function like this works beautifully in any monadic context: whenM :: Monad m => m Bool -> m () -> m () whenM condition action = do result <- condition if result then action else return () Whether dealing with potentially missing values, asynchronous operations, or state transformations, the same function can be employed without modification. There's something genuinely satisfying about this level of abstraction and reuse. OCaml's Different Approach Interestingly, the OCaml community seems less enthusiastic about monads as a primary abstraction tool. This might stem from several factors related to language design: Structural Differences OCaml lacks built-in typeclass support, relying instead on its module system and functors. While powerful in its own right, this approach might not make monad abstractions feel as natural or convenient: (* OCaml monad implementation requires more boilerplate *) module type MONAD = sig type 'a t val return : 'a -> 'a t val bind : 'a t -> ('a -> 'b t) -> 'b t end module OptionMonad : MONAD with type 'a t = 'a option = struct type 'a t = 'a option let return x = Some x let bind m f = match m with | None -> None | Some x -> f x end OCaml also doesn't offer syntactic sugar like Haskell's do notation, which makes monadic code in Haskell considerably more readable and expressive: -- Haskell's elegant do notation userInfo = do name <- getLine age <- readLn return (name, age) Compared to the more verbose OCaml equivalent: let user_info = get_line >>= fun name -> read_ln >>= fun age -> return (name, age) The readability difference becomes even more pronounced in more complex monadic operations. Philosophical Differences Beyond syntax, the languages differ in their fundamental approach to effects: Haskell is purely functional, making monads essential for managing effects in a principled way OCaml permits direct side effects, often making monadic abstractions optional This allows OCaml programmers to write more direct code when appropriate: (* Direct style in OCaml *) let get_user_info () = print_string "Name: "; let name = read_line () in print_string "Age: "; let age = int_of_string (read_line ()) in (name, age) OCaml's approach might favor pragmatism and directness in many cases, with programmers often preferring: Direct use of option and result types Module-level abstractions through functors Continuation-passing style when needed While this directness can be beneficial for immediate readability, it might come at the cost of some of the elegant uniformity that Haskell's monadic approach provides. Reflections on Language Design These differences highlight how programming language design shapes the idioms and patterns that emerge within their communities. Neither approach is objectively superior—they represent different philosophies about abstraction, explicitness, and the role of the type system. Haskell's approach encourages a high level of abstraction and consistency across different computational contexts, which can feel particularly satisfying when working with complex, interconnected systems. There's something intellectually pleasing about solving a problem once and having that solution generalize across many contexts. OCaml often favors more direct solutions that might be easier to reason about locally, though potentially at the cost of less uniformity across the codebase. This approach has its own virtues, particularly for systems where immediate comprehensibility is paramount. After working with both paradigms, I find myself drawn to the consistent abstractions that Haskell's approach provides, while still appreciating the pragmatic clarity that OCaml can offer in certain situations. The typeclasses and syntactic support in Haskell seem to unlock a particularly elegant way of structuring code that, while perhaps requiring a steeper initial learning curve, offers a uniquely satisfying programming experience. What patterns have you noticed in how different programming language communities approach similar problems? And have you found yourself drawn to the elegant abstractions of Haskell or the pragmatic approach of OCaml?

洪 民憙 (Hong Minhee)
@hongminhee@hackers.pub

While exploring functional programming languages, I've been reflecting on how different communities approach similar concepts. One pattern that seems particularly fascinating is how Haskell and OCaml communities differ in their embrace of monads as an abstraction tool.

The Elegant Power of Monads in Haskell

It's common to hear monads explained through analogies to concepts like JavaScript's Promise or jQuery chains. While these comparisons provide an entry point, they might miss what makes monads truly beautiful and powerful in Haskell's ecosystem.

The real strength appears to lie in the Monad typeclass itself. This elegant abstraction allows for creating generic functions and types that work with any type that shares the monad property. This seems to offer a profound unification of concepts that might initially appear unrelated:

  • You can write code once that works across many contexts (Maybe, [], IO, State, etc.)
  • Generic functions like sequence, mapM, and others become available across all monadic types
  • The same patterns and mental models apply consistently across different computational contexts

For example, a simple conditional function like this works beautifully in any monadic context:

whenM :: Monad m => m Bool -> m () -> m ()
whenM condition action = do
  result <- condition
  if result then action else return ()

Whether dealing with potentially missing values, asynchronous operations, or state transformations, the same function can be employed without modification. There's something genuinely satisfying about this level of abstraction and reuse.

OCaml's Different Approach

Interestingly, the OCaml community seems less enthusiastic about monads as a primary abstraction tool. This might stem from several factors related to language design:

Structural Differences

OCaml lacks built-in typeclass support, relying instead on its module system and functors. While powerful in its own right, this approach might not make monad abstractions feel as natural or convenient:

(* OCaml monad implementation requires more boilerplate *)
module type MONAD = sig
  type 'a t
  val return : 'a -> 'a t
  val bind : 'a t -> ('a -> 'b t) -> 'b t
end

module OptionMonad : MONAD with type 'a t = 'a option = struct
  type 'a t = 'a option
  let return x = Some x
  let bind m f = match m with
    | None -> None
    | Some x -> f x
end

OCaml also doesn't offer syntactic sugar like Haskell's do notation, which makes monadic code in Haskell considerably more readable and expressive:

-- Haskell's elegant do notation
userInfo = do
  name <- getLine
  age <- readLn
  return (name, age)

Compared to the more verbose OCaml equivalent:

let user_info =
  get_line >>= fun name ->
  read_ln >>= fun age ->
  return (name, age)

The readability difference becomes even more pronounced in more complex monadic operations.

Philosophical Differences

Beyond syntax, the languages differ in their fundamental approach to effects:

  • Haskell is purely functional, making monads essential for managing effects in a principled way
  • OCaml permits direct side effects, often making monadic abstractions optional

This allows OCaml programmers to write more direct code when appropriate:

(* Direct style in OCaml *)
let get_user_info () =
  print_string "Name: ";
  let name = read_line () in
  print_string "Age: ";
  let age = int_of_string (read_line ()) in
  (name, age)

OCaml's approach might favor pragmatism and directness in many cases, with programmers often preferring:

  • Direct use of option and result types
  • Module-level abstractions through functors
  • Continuation-passing style when needed

While this directness can be beneficial for immediate readability, it might come at the cost of some of the elegant uniformity that Haskell's monadic approach provides.

Reflections on Language Design

These differences highlight how programming language design shapes the idioms and patterns that emerge within their communities. Neither approach is objectively superior—they represent different philosophies about abstraction, explicitness, and the role of the type system.

Haskell's approach encourages a high level of abstraction and consistency across different computational contexts, which can feel particularly satisfying when working with complex, interconnected systems. There's something intellectually pleasing about solving a problem once and having that solution generalize across many contexts.

OCaml often favors more direct solutions that might be easier to reason about locally, though potentially at the cost of less uniformity across the codebase. This approach has its own virtues, particularly for systems where immediate comprehensibility is paramount.

After working with both paradigms, I find myself drawn to the consistent abstractions that Haskell's approach provides, while still appreciating the pragmatic clarity that OCaml can offer in certain situations. The typeclasses and syntactic support in Haskell seem to unlock a particularly elegant way of structuring code that, while perhaps requiring a steeper initial learning curve, offers a uniquely satisfying programming experience.

What patterns have you noticed in how different programming language communities approach similar problems? And have you found yourself drawn to the elegant abstractions of Haskell or the pragmatic approach of OCaml?

洪 民憙 (Hong Minhee) :nonbinary:
@hongminhee@hollo.social

Just what the internet needed: another attempt to explain ! 🙄 But this time I'm comparing and approaches to show why make all the difference. Turns out those JavaScript Promise analogies only tell half the story…

https://hackers.pub/@hongminhee/2025/monads

hackers.pub

Monads: Beyond Simple Analogies—Reflections on Functional Programming Paradigms

While exploring functional programming languages, I've been reflecting on how different communities approach similar concepts. One pattern that seems particularly fascinating is how Haskell and OCaml communities differ in their embrace of monads as an abstraction tool. The Elegant Power of Monads in Haskell It's common to hear monads explained through analogies to concepts like JavaScript's Promise or jQuery chains. While these comparisons provide an entry point, they might miss what makes monads truly beautiful and powerful in Haskell's ecosystem. The real strength appears to lie in the Monad typeclass itself. This elegant abstraction allows for creating generic functions and types that work with any type that shares the monad property. This seems to offer a profound unification of concepts that might initially appear unrelated: You can write code once that works across many contexts (Maybe, [], IO, State, etc.) Generic functions like sequence, mapM, and others become available across all monadic types The same patterns and mental models apply consistently across different computational contexts For example, a simple conditional function like this works beautifully in any monadic context: whenM :: Monad m => m Bool -> m () -> m () whenM condition action = do result <- condition if result then action else return () Whether dealing with potentially missing values, asynchronous operations, or state transformations, the same function can be employed without modification. There's something genuinely satisfying about this level of abstraction and reuse. OCaml's Different Approach Interestingly, the OCaml community seems less enthusiastic about monads as a primary abstraction tool. This might stem from several factors related to language design: Structural Differences OCaml lacks built-in typeclass support, relying instead on its module system and functors. While powerful in its own right, this approach might not make monad abstractions feel as natural or convenient: (* OCaml monad implementation requires more boilerplate *) module type MONAD = sig type 'a t val return : 'a -> 'a t val bind : 'a t -> ('a -> 'b t) -> 'b t end module OptionMonad : MONAD with type 'a t = 'a option = struct type 'a t = 'a option let return x = Some x let bind m f = match m with | None -> None | Some x -> f x end OCaml also doesn't offer syntactic sugar like Haskell's do notation, which makes monadic code in Haskell considerably more readable and expressive: -- Haskell's elegant do notation userInfo = do name <- getLine age <- readLn return (name, age) Compared to the more verbose OCaml equivalent: let user_info = get_line >>= fun name -> read_ln >>= fun age -> return (name, age) The readability difference becomes even more pronounced in more complex monadic operations. Philosophical Differences Beyond syntax, the languages differ in their fundamental approach to effects: Haskell is purely functional, making monads essential for managing effects in a principled way OCaml permits direct side effects, often making monadic abstractions optional This allows OCaml programmers to write more direct code when appropriate: (* Direct style in OCaml *) let get_user_info () = print_string "Name: "; let name = read_line () in print_string "Age: "; let age = int_of_string (read_line ()) in (name, age) OCaml's approach might favor pragmatism and directness in many cases, with programmers often preferring: Direct use of option and result types Module-level abstractions through functors Continuation-passing style when needed While this directness can be beneficial for immediate readability, it might come at the cost of some of the elegant uniformity that Haskell's monadic approach provides. Reflections on Language Design These differences highlight how programming language design shapes the idioms and patterns that emerge within their communities. Neither approach is objectively superior—they represent different philosophies about abstraction, explicitness, and the role of the type system. Haskell's approach encourages a high level of abstraction and consistency across different computational contexts, which can feel particularly satisfying when working with complex, interconnected systems. There's something intellectually pleasing about solving a problem once and having that solution generalize across many contexts. OCaml often favors more direct solutions that might be easier to reason about locally, though potentially at the cost of less uniformity across the codebase. This approach has its own virtues, particularly for systems where immediate comprehensibility is paramount. After working with both paradigms, I find myself drawn to the consistent abstractions that Haskell's approach provides, while still appreciating the pragmatic clarity that OCaml can offer in certain situations. The typeclasses and syntactic support in Haskell seem to unlock a particularly elegant way of structuring code that, while perhaps requiring a steeper initial learning curve, offers a uniquely satisfying programming experience. What patterns have you noticed in how different programming language communities approach similar problems? And have you found yourself drawn to the elegant abstractions of Haskell or the pragmatic approach of OCaml?

洪 民憙 (Hong Minhee)
@hongminhee@hackers.pub

While exploring functional programming languages, I've been reflecting on how different communities approach similar concepts. One pattern that seems particularly fascinating is how Haskell and OCaml communities differ in their embrace of monads as an abstraction tool.

The Elegant Power of Monads in Haskell

It's common to hear monads explained through analogies to concepts like JavaScript's Promise or jQuery chains. While these comparisons provide an entry point, they might miss what makes monads truly beautiful and powerful in Haskell's ecosystem.

The real strength appears to lie in the Monad typeclass itself. This elegant abstraction allows for creating generic functions and types that work with any type that shares the monad property. This seems to offer a profound unification of concepts that might initially appear unrelated:

  • You can write code once that works across many contexts (Maybe, [], IO, State, etc.)
  • Generic functions like sequence, mapM, and others become available across all monadic types
  • The same patterns and mental models apply consistently across different computational contexts

For example, a simple conditional function like this works beautifully in any monadic context:

whenM :: Monad m => m Bool -> m () -> m ()
whenM condition action = do
  result <- condition
  if result then action else return ()

Whether dealing with potentially missing values, asynchronous operations, or state transformations, the same function can be employed without modification. There's something genuinely satisfying about this level of abstraction and reuse.

OCaml's Different Approach

Interestingly, the OCaml community seems less enthusiastic about monads as a primary abstraction tool. This might stem from several factors related to language design:

Structural Differences

OCaml lacks built-in typeclass support, relying instead on its module system and functors. While powerful in its own right, this approach might not make monad abstractions feel as natural or convenient:

(* OCaml monad implementation requires more boilerplate *)
module type MONAD = sig
  type 'a t
  val return : 'a -> 'a t
  val bind : 'a t -> ('a -> 'b t) -> 'b t
end

module OptionMonad : MONAD with type 'a t = 'a option = struct
  type 'a t = 'a option
  let return x = Some x
  let bind m f = match m with
    | None -> None
    | Some x -> f x
end

OCaml also doesn't offer syntactic sugar like Haskell's do notation, which makes monadic code in Haskell considerably more readable and expressive:

-- Haskell's elegant do notation
userInfo = do
  name <- getLine
  age <- readLn
  return (name, age)

Compared to the more verbose OCaml equivalent:

let user_info =
  get_line >>= fun name ->
  read_ln >>= fun age ->
  return (name, age)

The readability difference becomes even more pronounced in more complex monadic operations.

Philosophical Differences

Beyond syntax, the languages differ in their fundamental approach to effects:

  • Haskell is purely functional, making monads essential for managing effects in a principled way
  • OCaml permits direct side effects, often making monadic abstractions optional

This allows OCaml programmers to write more direct code when appropriate:

(* Direct style in OCaml *)
let get_user_info () =
  print_string "Name: ";
  let name = read_line () in
  print_string "Age: ";
  let age = int_of_string (read_line ()) in
  (name, age)

OCaml's approach might favor pragmatism and directness in many cases, with programmers often preferring:

  • Direct use of option and result types
  • Module-level abstractions through functors
  • Continuation-passing style when needed

While this directness can be beneficial for immediate readability, it might come at the cost of some of the elegant uniformity that Haskell's monadic approach provides.

Reflections on Language Design

These differences highlight how programming language design shapes the idioms and patterns that emerge within their communities. Neither approach is objectively superior—they represent different philosophies about abstraction, explicitness, and the role of the type system.

Haskell's approach encourages a high level of abstraction and consistency across different computational contexts, which can feel particularly satisfying when working with complex, interconnected systems. There's something intellectually pleasing about solving a problem once and having that solution generalize across many contexts.

OCaml often favors more direct solutions that might be easier to reason about locally, though potentially at the cost of less uniformity across the codebase. This approach has its own virtues, particularly for systems where immediate comprehensibility is paramount.

After working with both paradigms, I find myself drawn to the consistent abstractions that Haskell's approach provides, while still appreciating the pragmatic clarity that OCaml can offer in certain situations. The typeclasses and syntactic support in Haskell seem to unlock a particularly elegant way of structuring code that, while perhaps requiring a steeper initial learning curve, offers a uniquely satisfying programming experience.

What patterns have you noticed in how different programming language communities approach similar problems? And have you found yourself drawn to the elegant abstractions of Haskell or the pragmatic approach of OCaml?

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Sum types and subtypes and unions. ~ Justin Le. blog.jle.im/entry/sum-types-an

blog.jle.im

Sum Types and Subtypes and Unions

There’s yet again been a bit of functional programming-adjacent twitter drama recently, but it’s actually sort of touched into some subtleties about sum types that I am asked about (and think about) a lot nowadays. So, I’d like to take this opportunity to talk a bit about the “why” and nature of sum types and how to use them effectively, and how they contrast with other related concepts in programming and software development and when even cases where sum types aren’t the best option.

Simon Michael
@simonmic@fosstodon.org

hledger 1.42 is out, with new run and repl commands.
Thank you to contributors Dmitry Astapov, gesh, Thomas
Miedema, Joschua Kesper, and Lars Kellogg-Stedman !

- github.com/simonmichael/hledge
- hledger.org/relnotes.html#2025
- hledger.org/install

is free, robust, friendly, multicurrency, double-entry,
software for unix, mac, windows, and the web,
written in for reliability.

hledger.org

Install - hledger

plain text accounting, made easy

DiazCarrete
@DiazCarrete@hachyderm.io

If I'm using "async" in Haskell to spawn a thread hackage.haskell.org/package/as and I want the thread to know about its own Async handle, which would be the best way of doing so?

It seems hat "fixIO" hackage.haskell.org/package/ba could do the trick, but I'm not sure if it would be a good idea 🤔

Example of where I used "fixIO" for that purpose: discourse.haskell.org/t/dynami

discourse.haskell.org

Dynamic number of asyncs

I think we should keep the use of link but dispense with the nested withAsyncs. Instead of that, we should keep an explicit set of Async values in a mutable reference. The main thread can cancel the pending asyncs as needed. Something like (haven’t actually tested it 😅) main :: IO () main = do ref <- newIORef $ Data.Set.empty @(Async ()) let register theAsync = modifyIORef' ref $ Data.Set.insert theAsync finallyDeregister theAsync = flip finally $ ...

Beady Belle Fanchannel
@Profpatsch@mastodon.xyz

Let’s goooooo

Since GHC 9.6, any non-empty double quoted string can be used as a label. The restriction that the label must be a valid identifier has also been lifted. Examples of newly allowed syntax: Leading capital letters: #Foo equivalant to getLabel @”Foo” Numeric characters: #3.14 equivalent to getLabel @”3.14” Arbitrary strings: #”Hello, World!” equivalent to getLabel @”Hello, World!” Here is an example of the more permissive use of this extension, available since GHC 9.6:
ALT text

Since GHC 9.6, any non-empty double quoted string can be used as a label. The restriction that the label must be a valid identifier has also been lifted. Examples of newly allowed syntax: Leading capital letters: #Foo equivalant to getLabel @”Foo” Numeric characters: #3.14 equivalent to getLabel @”3.14” Arbitrary strings: #”Hello, World!” equivalent to getLabel @”Hello, World!” Here is an example of the more permissive use of this extension, available since GHC 9.6:

-- case-match on an e2 with a t2 that provides the relevant functions caseE2 :: forall l1 t1 l2 t2 matcher r. ( HasField l1 matcher (t1 -> r), HasField l2 matcher (t2 -> r) ) => matcher -> E2 l1 t1 l2 t2 -> r {-# INLINE caseE2 #-} caseE2 m e2 = do let f1 = getField @l1 m let f2 = getField @l2 m case e2 of E21 a -> f1 $ getField @l1 a E22 b -> f2 $ getField @l2 b t2 :: forall l1 t1 l2 t2. LabelPrx l1 -> t1 -> LabelPrx l2 -> t2 -> T2 l1 t1 l2 t2 {-# INLINE t2 #-} t2 LabelPrx a LabelPrx b = T2 (label @l1 a) (label @l2 b) data LabelPrx (l :: Symbol) = LabelPrx instance (l ~ l') => IsLabel l (LabelPrx l') where fromLabel = LabelPrx instance (t ~ t') => IsLabel l (t -> (Label l t')) where fromLabel = label @l
ALT text

-- case-match on an e2 with a t2 that provides the relevant functions caseE2 :: forall l1 t1 l2 t2 matcher r. ( HasField l1 matcher (t1 -> r), HasField l2 matcher (t2 -> r) ) => matcher -> E2 l1 t1 l2 t2 -> r {-# INLINE caseE2 #-} caseE2 m e2 = do let f1 = getField @l1 m let f2 = getField @l2 m case e2 of E21 a -> f1 $ getField @l1 a E22 b -> f2 $ getField @l2 b t2 :: forall l1 t1 l2 t2. LabelPrx l1 -> t1 -> LabelPrx l2 -> t2 -> T2 l1 t1 l2 t2 {-# INLINE t2 #-} t2 LabelPrx a LabelPrx b = T2 (label @l1 a) (label @l2 b) data LabelPrx (l :: Symbol) = LabelPrx instance (l ~ l') => IsLabel l (LabelPrx l') where fromLabel = LabelPrx instance (t ~ t') => IsLabel l (t -> (Label l t')) where fromLabel = label @l

matcher :: T2 "oh yeah" (Int -> String) "mylabel" (a -> a) matcher = t2 #"oh yeah" (\(i :: Int) -> show $ i + 1) #mylabel id bar :: E2 "oh yeah" Int "mylabel" String bar = E21 (#"oh yeah" 42) baz :: String baz = bar & caseE2 matcher
ALT text

matcher :: T2 "oh yeah" (Int -> String) "mylabel" (a -> a) matcher = t2 #"oh yeah" (\(i :: Int) -> show $ i + 1) #mylabel id bar :: E2 "oh yeah" Int "mylabel" String bar = E21 (#"oh yeah" 42) baz :: String baz = bar & caseE2 matcher

Beady Belle Fanchannel
@Profpatsch@mastodon.xyz

Let’s goooooo

Since GHC 9.6, any non-empty double quoted string can be used as a label. The restriction that the label must be a valid identifier has also been lifted. Examples of newly allowed syntax: Leading capital letters: #Foo equivalant to getLabel @”Foo” Numeric characters: #3.14 equivalent to getLabel @”3.14” Arbitrary strings: #”Hello, World!” equivalent to getLabel @”Hello, World!” Here is an example of the more permissive use of this extension, available since GHC 9.6:
ALT text

Since GHC 9.6, any non-empty double quoted string can be used as a label. The restriction that the label must be a valid identifier has also been lifted. Examples of newly allowed syntax: Leading capital letters: #Foo equivalant to getLabel @”Foo” Numeric characters: #3.14 equivalent to getLabel @”3.14” Arbitrary strings: #”Hello, World!” equivalent to getLabel @”Hello, World!” Here is an example of the more permissive use of this extension, available since GHC 9.6:

-- case-match on an e2 with a t2 that provides the relevant functions caseE2 :: forall l1 t1 l2 t2 matcher r. ( HasField l1 matcher (t1 -> r), HasField l2 matcher (t2 -> r) ) => matcher -> E2 l1 t1 l2 t2 -> r {-# INLINE caseE2 #-} caseE2 m e2 = do let f1 = getField @l1 m let f2 = getField @l2 m case e2 of E21 a -> f1 $ getField @l1 a E22 b -> f2 $ getField @l2 b t2 :: forall l1 t1 l2 t2. LabelPrx l1 -> t1 -> LabelPrx l2 -> t2 -> T2 l1 t1 l2 t2 {-# INLINE t2 #-} t2 LabelPrx a LabelPrx b = T2 (label @l1 a) (label @l2 b) data LabelPrx (l :: Symbol) = LabelPrx instance (l ~ l') => IsLabel l (LabelPrx l') where fromLabel = LabelPrx instance (t ~ t') => IsLabel l (t -> (Label l t')) where fromLabel = label @l
ALT text

-- case-match on an e2 with a t2 that provides the relevant functions caseE2 :: forall l1 t1 l2 t2 matcher r. ( HasField l1 matcher (t1 -> r), HasField l2 matcher (t2 -> r) ) => matcher -> E2 l1 t1 l2 t2 -> r {-# INLINE caseE2 #-} caseE2 m e2 = do let f1 = getField @l1 m let f2 = getField @l2 m case e2 of E21 a -> f1 $ getField @l1 a E22 b -> f2 $ getField @l2 b t2 :: forall l1 t1 l2 t2. LabelPrx l1 -> t1 -> LabelPrx l2 -> t2 -> T2 l1 t1 l2 t2 {-# INLINE t2 #-} t2 LabelPrx a LabelPrx b = T2 (label @l1 a) (label @l2 b) data LabelPrx (l :: Symbol) = LabelPrx instance (l ~ l') => IsLabel l (LabelPrx l') where fromLabel = LabelPrx instance (t ~ t') => IsLabel l (t -> (Label l t')) where fromLabel = label @l

matcher :: T2 "oh yeah" (Int -> String) "mylabel" (a -> a) matcher = t2 #"oh yeah" (\(i :: Int) -> show $ i + 1) #mylabel id bar :: E2 "oh yeah" Int "mylabel" String bar = E21 (#"oh yeah" 42) baz :: String baz = bar & caseE2 matcher
ALT text

matcher :: T2 "oh yeah" (Int -> String) "mylabel" (a -> a) matcher = t2 #"oh yeah" (\(i :: Int) -> show $ i + 1) #mylabel id bar :: E2 "oh yeah" Int "mylabel" String bar = E21 (#"oh yeah" 42) baz :: String baz = bar & caseE2 matcher

Simon Michael
@simonmic@fosstodon.org

hledger 1.42 is out, with new run and repl commands.
Thank you to contributors Dmitry Astapov, gesh, Thomas
Miedema, Joschua Kesper, and Lars Kellogg-Stedman !

- github.com/simonmichael/hledge
- hledger.org/relnotes.html#2025
- hledger.org/install

is free, robust, friendly, multicurrency, double-entry,
software for unix, mac, windows, and the web,
written in for reliability.

hledger.org

Install - hledger

plain text accounting, made easy

Haskell Weekly
@haskell_discussions@mastodon.social

Aztecs v0.10: A modular game-engine and ECS for Haskell (now with a simpler design featuring applicative queries and monadic systems)

github.com/aztecs-hs/aztecs

Discussions: discu.eu/q/https://github.com/

discu.eu

GitHub - aztecs-hs/aztecs: A modular game engine and ECS for Haskell - discu.eu

Discussions and related articles for «GitHub - aztecs-hs/aztecs: A modular game engine and ECS for Haskell»

Haskell Weekly
@haskell_discussions@mastodon.social

Continuing introducing Я control flow primitives step by step. It's time for monoidal functors:

muratkasimov.art/Ya/Articles/C

Discussions: discu.eu/q/https://muratkasimo

discu.eu

Я ☞ Articles ☞ Context-free effects with Monoidal functors - discu.eu

Discussions and related articles for «Я ☞ Articles ☞ Context-free effects with Monoidal functors»

Coding Gardener
@cdavies@mastodon.scot

I really need to master functions and functional programming generally. There's something about them that addles my brain. It's bothering me that I'm not good at them.
I can read through other people's functions and mostly work out what they do, but I struggle with writing my own.

I've read blogs that suggest learning or as they are pure functional languages, and it helps solidify the logic.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared March 3, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 2, 2025

The readings shared in Bluesky on 2 March 2025 are Waterproof: Transforming a proof assistant into an educational tool. ~ Aalt Jelle Wemmenhove. #ITP #Coq #Math #Education Computer assisted mathemati

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared February 28, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 28, 2025

The readings shared in Bluesky on 28 February 2025 are Is mathematics obsolete? ~ Jeremy Avigad. #Math #ITP #LeanProver #AI #LLMs Faithful logic embeddings in HOL (A recipe to have it all: deep and s

Haskell Weekly
@haskell_discussions@mastodon.social

Static binary with Nix, problems with hmatrix

github.com/b4er/recalc/compare

Discussions: discu.eu/q/https://github.com/

discu.eu

Comparing main...dev/hmatrix · b4er/recalc · GitHub - discu.eu

Discussions and related articles for «Comparing main...dev/hmatrix · b4er/recalc · GitHub»

Haskell Weekly
@haskell_discussions@mastodon.social

Step-by-Step Guide to Installing GHC-JS (Haskell JavaScript FFI)

tushar-adhatrao.in/blogs/haske

Discussions: discu.eu/q/https://www.tushar-

discu.eu

Step-by-Step Guide to Installing GHC-JS (Haskell JavaScript FFI) - Tushar Adhatrao - discu.eu

Discussions and related articles for «Step-by-Step Guide to Installing GHC-JS (Haskell JavaScript FFI) - Tushar Adhatrao»

Kyle Ackerman
@kack@mastodon.social

Trying to figure out what to use in my next personal project. Trying to stay away from touching JS. I have been considering becuase I like . I also have been considering and becuase I love . I guess I could choose any backend but I am really looking for a frontend replacement to make a QOL improvement

Andres Löh
@kosmikus@functional.cafe

Please consider nominating yourself to be a member of the Foundation Board: discourse.haskell.org/t/2025-c

discourse.haskell.org

2025 Call for nominations for the Haskell Foundation

Hello! everyone The Haskell Foundation’s directors are pleased to announce the nomination process for seats on the Foundation’s board of directors. The board is the ultimate decision-making body of the Foundation and provides its strategic leadership. It ensures that the Foundation is working toward achieving its mission, and it appoints and supervises senior members of the Foundation’s staff. Following the board membership lifecycle rules, we are announcing five open seats. Directors that ha...

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared February 24, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 24, 2025

The readings shared in Bluesky on 24 February 2025 are Formalising Brauer group and group cohomology in Lean4.~ Jujian Zhang. #ITP #LeanProver #Math The Haskell road to logic, math and programming. ~

Haskell Weekly
@haskell_discussions@mastodon.social

Multi Line Strings are now supported in GHC 9.12.1!

ghc.gitlab.haskell.org/ghc/doc

Discussions: discu.eu/q/https://ghc.gitlab.

discu.eu

6.9.9. Multiline string literals — Glasgow Haskell Compiler 9.13.20250222 User's Guide - discu.eu

Discussions and related articles for «6.9.9. Multiline string literals — Glasgow Haskell Compiler 9.13.20250222 User's Guide»

Abhinav 🧭
@abnv@fantastic.earth

In an alternative timeline where is the norm instead of Object-oriented programming, and is the most popular instead of , there is a list of tutorials trying to explain what Objects are to programmers in terms of FP concepts, the most popular of which is, “Objects are Comonads”.

However, we don't live in that timeline, so we'll have to be content with the inverse article, “Comonads are Objects” haskellforall.com/2013/02/you- .

haskellforall.com

Comonads are objects

Haskell programmers popularized the use of monads to structure imperative computations, complete with syntactic sugar in the form of do not...

Abhinav 🧭
@abnv@fantastic.earth

In an alternative timeline where is the norm instead of Object-oriented programming, and is the most popular instead of , there is a list of tutorials trying to explain what Objects are to programmers in terms of FP concepts, the most popular of which is, “Objects are Comonads”.

However, we don't live in that timeline, so we'll have to be content with the inverse article, “Comonads are Objects” haskellforall.com/2013/02/you- .

haskellforall.com

Comonads are objects

Haskell programmers popularized the use of monads to structure imperative computations, complete with syntactic sugar in the form of do not...

Abhinav 🧭
@abnv@fantastic.earth

Comparing the chart of tutorials by year[1] with the Gartner hype cycle graph, it seems like we are almost at the Peak of Inflated Expectations phase now.

[1]: From the list of Monad tutorials (wiki.haskell.org/Monad_tutoria).

In my lifetime, I hope to see the Slope of Enlightenment phase when people stop asking what a Monad is, and the further Plateau of Productivity phase when everyone knows what it is.

A line chart showing number of Monad tutorials published yearly from 1990 to 2023. The number grows slowly at the beginning, then rises sharply starting 2015, then seems to plateau around 2022.
ALT text

A line chart showing number of Monad tutorials published yearly from 1990 to 2023. The number grows slowly at the beginning, then rises sharply starting 2015, then seems to plateau around 2022.

The graph of the Gartner Hype Cycle.
ALT text

The graph of the Gartner Hype Cycle.

Haskell Weekly
@haskell_discussions@mastodon.social

First Haskell Project (an implementation of Irving's algorithm to find roomates)

github.com/TheArjunAgarwal/mar

Discussions: discu.eu/q/https://github.com/

discu.eu

GitHub - TheArjunAgarwal/marriage-pact: OpenPact is an open-source Haskell implementation inspired by Marriage Pact (marriagepact.com). It also has a mode to match homosexual pairs and best friends. - discu.eu

Discussions and related articles for «GitHub - TheArjunAgarwal/marriage-pact: OpenPact is an open-source Haskell implementation inspired by Marriage Pact (marriagepact.com). It also has a mode to match homosexual pairs and best friends.»

Haskell Weekly
@haskell_discussions@mastodon.social

Я ☞ Bind and traverse with Kleisli morphisms

muratkasimov.art/Ya/Articles/B

Discussions: discu.eu/q/https://muratkasimo

discu.eu

Я ☞ Articles ☞ Bind and traverse with Kleisli morphisms - discu.eu

Discussions and related articles for «Я ☞ Articles ☞ Bind and traverse with Kleisli morphisms»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared February 19, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 19, 2025

The readings shared in Bluesky on 19 February 2025 are Automating math (Computers can already help verify proofs. One day soon, AI may be able to come up with new ones). ~ Adam Marblestone.h#ai-mathe

HaskellOrg
@haskell@fosstodon.org

"Monad of No Return: Next Steps" discourse.haskell.org/t/monad-

discourse.haskell.org

Monad of No Return: Next Steps

The proposal monad of no return has been in the process of being implemented for a while. I’m collecting community feedback on the proposal (and specifically phase 3) in the hopes that as a community we can move forwards in making Haskell a better language. I encourage people to read the proposal above, but I’ll summarise and quote below where relevant. What is this proposal? The proposal outlines that with making Applicative a superclass of Monad (which happened with Functor-Applicative-Monad ...

Haskell Weekly
@haskell_discussions@mastodon.social

Announcing Symbolize 1.0.1.0: String Interning / Global Symbol Table, with Garbage Collection

discourse.haskell.org/t/symbol

Discussions: discu.eu/q/https://discourse.h

discu.eu

Symbolize 1.0.1.0: Efficient string interning / global Symbol table, with Garbage Collection - Announcements - Haskell Community - discu.eu

Discussions and related articles for «Symbolize 1.0.1.0: Efficient string interning / global Symbol table, with Garbage Collection - Announcements - Haskell Community»

Haskell Weekly
@haskell_discussions@mastodon.social

Haskell coach to stick with women's team for basketball playoffs despite having been fired

www2.ljworld.com/news/general-

Discussions: discu.eu/q/https://www2.ljworl

discu.eu

Haskell coach to stick with women’s team for basketball playoffs, despite having been fired | News, Sports, Jobs - Lawrence Journal-World: news, information, headlines and events in Lawrence, Kansas - discu.eu

Discussions and related articles for «Haskell coach to stick with women’s team for basketball playoffs, despite having been fired | News, Sports, Jobs - Lawrence Journal-World: news, information, headlines and events in Lawrence, Kansas»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Natural transformations as a basis of control. ~ Murat Kasimov. muratkasimov.art/Ya/Articles/N

muratkasimov.art

Я ☞ Articles ☞ Natural transformations as a basis of control

Introduction How do you approach learning a new foreign language? Starting with an alphabet, looking for grammar books at local shops or insulting native speakers with your distorted ...

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared February 16, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 16, 2025

The readings shared in Bluesky on 16 February 2025 are The relationship between category theory, lambda calculus, and functional programming in Haskell. ~ Antonio Montano. #Haskell #FunctionalProgram

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

The relationship between category theory, lambda calculus, and functional programming in Haskell. ~ Antonio Montano. 4m4.it/posts/category-theory-f

4m4.it

The Relationship Between Category Theory, Lambda Calculus, and Functional Programming in Haskell – Random Bits of Knowledge

This post explores the deep connections between functional programming, lambda calculus, and category theory, with a particular focus on composability, a foundational principle in both mathematics and software engineering. Haskell, a functional programming language deeply rooted in these mathematical frameworks, serves as the practical implementation of these concepts, demonstrating how abstract theories can be applied to build robust, scalable, and maintainable software systems. We present key concepts such as function composition, functors, monads, and cartesian closed categories, illustrating their significance in modern software development. Additionally, it highlights how formal composability, grounded in lambda calculus and category theory, is crucial for managing the growing complexity of software systems. The discussion extends to the future implications of formal composability in the context of machine learning and automated software development, emphasizing its potential to transform the way complex systems are designed and verified. Finally, the essay provides a comprehensive self-study path for those interested in mastering Haskell, category theory, and their applications in various domains, including secure coding, asynchronous systems, and blockchain technology.

Haskell Weekly
@haskell_discussions@mastodon.social

PatternMatchable, Yoneda Embedding, and Adjunction - Show and Tell

discourse.haskell.org/t/patter

Discussions: discu.eu/q/https://discourse.h

discu.eu

PatternMatchable, Yoneda Embedding, and Adjunction - Show and Tell - Haskell Community - discu.eu

Discussions and related articles for «PatternMatchable, Yoneda Embedding, and Adjunction - Show and Tell - Haskell Community»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared February 14, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 14, 2025

The readings shared in Bluesky on 14 February 2025 are Language models for verifiable mathematical automation (Interaction, integration, and autoformalization). ~ Qiaochu Jiang. #ITP #IsabelleHOL #LL

Philipp :emacs: :nixos:
@pmidden@fosstodon.org

I should learn and use . I could use it for work projects, and it would fit neatly, with being safe, fast, and easily installable/deployable.

But it somehow doesn't "tickle" me. I keep coming back to these (comparatively) more exotic languages like . Not sure why, but I think it offers more learning experiences, possibly more rigidity?

Haskell Weekly
@haskell_discussions@mastodon.social

The Haskell Unfolder Episode 39: deriving strategies

youtube.com/watch?index=39&lis

Discussions: discu.eu/q/https://www.youtube

discu.eu

The Haskell Unfolder Episode 39: deriving strategies - YouTube - discu.eu

Discussions and related articles for «The Haskell Unfolder Episode 39: deriving strategies - YouTube»

Robin Palotai
@robinp@mastodon.social · Reply to Abhinav 🧭

@abnv could do it with , but of the libraries that sound promising
- 1 has a concise API but is experimental and misses tests
- 1 depends on an ancient base
- 1 has a too conservative licence
- 1 where you need to pass contraprovariant subfunctors and then project the result to 1.5D-space
- 1 uses a logging framework monad dep that is not compatible with your stack
- 1 is practical, but has bug that is fixed locally by users who were too busy to publish them
- 1 you need to jailbreak nix

redmp (EDITED)
@redmp@recurse.social

@jmct challenge accepted

(baton roue image macro) * man riding bike: "efficient pure functional programming" * man puts stick between spokes: "lazy evaluation" * man on ground holding knee: "BangPatterns StrictData Strict MagicHash UnboxedTuples UnliftedNewtypes UnboxedSums UnliftedDatatypes" The haskell logo is pasted over the man's face in all frames.
ALT text

(baton roue image macro) * man riding bike: "efficient pure functional programming" * man puts stick between spokes: "lazy evaluation" * man on ground holding knee: "BangPatterns StrictData Strict MagicHash UnboxedTuples UnliftedNewtypes UnboxedSums UnliftedDatatypes" The haskell logo is pasted over the man's face in all frames.

Robin Palotai
@robinp@mastodon.social · Reply to Abhinav 🧭

@abnv could do it with , but of the libraries that sound promising
- 1 has a concise API but is experimental and misses tests
- 1 depends on an ancient base
- 1 has a too conservative licence
- 1 where you need to pass contraprovariant subfunctors and then project the result to 1.5D-space
- 1 uses a logging framework monad dep that is not compatible with your stack
- 1 is practical, but has bug that is fixed locally by users who were too busy to publish them
- 1 you need to jailbreak nix

Andres Löh
@kosmikus@functional.cafe

Tomorrow, 2025-02-11, we'll live-stream a new episode of the . Edsko and I will discuss the various strategies for deriving instances that GHC offers and their relative strengths and weaknesses. Hope to see you all there! youtube.com/watch?v=NEUbp2CsuN

youtube.com

The Haskell Unfolder Episode 39: deriving strategies

In this episode we'll discuss the the four different ways GHC offers for deriving class instance definitions: the classic "stock" deriving, generalised "newt...

Fraser Tweedale
@hackuador@functional.cafe

Talk change for tonight. The explicit substitutions talk will be rescheduled. In its place, parser combinators in (live-coding a JSON parser from scratch).

Be there or be a lambda cube. lu.ma/85i70qns

lu.ma

BFPG Meetup - February 2025 - Parser combinators + Mentor networking session · Luma

Agenda 18:00: Welcome and setup Presentation #1: Live coding a JSON parser - Donovan Crichton Presentation #2: Mentor networking session - hosted by Jack…

Haskell Weekly
@haskell_discussions@mastodon.social

Я ☞ Natural transformations as a basis of control flow

muratkasimov.art/Ya/Articles/N

Discussions: discu.eu/q/https://muratkasimo

discu.eu

Я ☞ Articles ☞ Natural transformations as a basis of control - discu.eu

Discussions and related articles for «Я ☞ Articles ☞ Natural transformations as a basis of control»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Turner, Bird, Eratosthenes: An eternal burning thread. ~ Jeremy Gibbons. cambridge.org/core/journals/jo

cambridge.org

Turner, Bird, Eratosthenes: An eternal burning thread | Journal of Functional Programming | Cambridge Core

Turner, Bird, Eratosthenes: An eternal burning thread - Volume 35

Haskell Weekly
@haskell_discussions@mastodon.social

Introducing Haskell Run – A VS Code Extension to Execute Haskell Instantly!

marketplace.visualstudio.com/i

Discussions: discu.eu/q/https://marketplace

discu.eu

Introducing Haskell Run – A VS Code Extension to Execute Haskell Instantly! - discu.eu

Discussions and related articles for «Introducing Haskell Run – A VS Code Extension to Execute Haskell Instantly!»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared February 6, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared February 6, 2025

The readings shared in Bluesky on 6 February 2025 are A formalization of Borel determinacy in Lean. ~ Sven Manthe. #ITP #LeanProver #Math Simplifying formal proof-generating models with ChatGPT and b

NoCanDo
@escape_velocity@functional.cafe

I fucking hate cabal for the inexcusable design decision that all info for a project must be in the cabal file and therefore cabal cannot figure out what modules are part of the project folder structure. Why? Because this means I can’t get extension support for files until I explicitly add the bloody module to the cabal file. When asked about it on the Haskell discord I am told that this is an unfortunate consequence of the above and that it’s on me to use some ugly workaround.

For such a fundamental pain in the UX, the only acceptable response from devs should be to stuff their pride deep deep down and go back to the fucking drawing board and throw out such hideous design decisions.

Philippa Cowderoy
@flippac@types.pl · Reply to julesh

@julesh I spent a lot of time in freenode pointing out that no, haskell could go fuck itself re various limitations because the suggestions I was being given were either workaround grade (which, tbf, was usually acknowledged) or attempts to tell me I had an XY problem and Y wasn't "you're using haskell"

Some of them have, at least, improved significantly - but there's also a reason I'm deliberately keeping Nooblog and its successors small enough to piss people off, which is that I absolutely should not be maintaining a language others are building on top of! Cribbing off my design is more than fine by me.

Haskell Weekly
@haskell_discussions@mastodon.social

Type-level interfaces in Haskell and Rust (talk, Functional Conf 2025)

youtu.be/vKAuSD0RnmY?si=JG4gHk

Discussions: discu.eu/q/https://youtu.be/vK

discu.eu

Type-level interfaces in Haskell and Rust (talk, Functional Conf 2025) - discu.eu

Discussions and related articles for «Type-level interfaces in Haskell and Rust (talk, Functional Conf 2025)»

Abhinav 🧭
@abnv@fantastic.earth

Over the weekend, I spent a couple of hours through Patrick Thomson's series of blog posts on Recursion Schemes with blog.sumtypeofway.com/posts/re, and it has been most helpful in understanding the topic. I have tried reading the docs of the eponymous package before, to no avail. That's why I love reading (and writing) tutorials.

I downloaded the posts and converted them to an e-book for offline reading. It was over a hundred pages but it was so engrossing, I couldn't put it down! There are not many blog posts that I could say the same about. Definitely a recommended read if you are interested in and .

blog.sumtypeofway.com

adventures in uncertainty: Recursion Schemes, Part VI: Comonads, Composition, and Generality

HaskellOrg
@haskell@fosstodon.org

Registrations for are open!

fosstodon.org/@zurihac/1139237

fosstodon.org

ZuriHac (@zurihac@fosstodon.org)

Registration for the ZuriHac 2025 is now open! Who's excited for another 3 days of wonderful talks, catching up with friends, happy Haskell hacking, and lake swims? 🔗 Click to register: https://zureg.zfoh.ch/register 🔗 Visit the website: https://zfoh.ch/zurihac2025/ #ZuriHac #ZuriHac2025 #functionalprogramming

Haskell Weekly
@haskell_discussions@mastodon.social

[Well-Typed] An introduction to Cabal Hooks for package authors

well-typed.com/blog/2025/01/ca

Discussions: discu.eu/q/https://www.well-ty

discu.eu

An introduction to Cabal Hooks for package authors - Well-Typed: The Haskell Consultants - discu.eu

Discussions and related articles for «An introduction to Cabal Hooks for package authors - Well-Typed: The Haskell Consultants»

Haskell Weekly
@haskell_discussions@mastodon.social

Add safe integral conversions to base · Issue #314 · haskell/core-libraries-committee

github.com/haskell/core-librar

Discussions: discu.eu/q/https://github.com/

discu.eu

Add safe integral conversions to base · Issue #314 · haskell/core-libraries-committee · GitHub - discu.eu

Discussions and related articles for «Add safe integral conversions to base · Issue #314 · haskell/core-libraries-committee · GitHub»

Haskell Weekly
@haskell_discussions@mastodon.social

Using the Tardis Monad in a compiler optimisation pass.

icicle-lang.github.io/posts/20

Discussions: discu.eu/q/https://icicle-lang

discu.eu

Icicle Lang - Destructive Updates - a Stitch in Time - discu.eu

Discussions and related articles for «Icicle Lang - Destructive Updates - a Stitch in Time»

Haskell Weekly
@haskell_discussions@mastodon.social

Advent of Code in Haskell: Reflections and write-ups for all 25 days of 2024

blog.jle.im/entry/advent-of-co

Discussions: discu.eu/q/https://blog.jle.im

discu.eu

Advent of Code 2024: Haskell Solution Reflections for all 25 Days · in Code - discu.eu

Discussions and related articles for «Advent of Code 2024: Haskell Solution Reflections for all 25 Days · in Code»

Haskell Weekly
@haskell_discussions@mastodon.social

Failed to install HLS

haskell.org/ghcup/sh/bootstrap

Discussions: discu.eu/q/https://www.haskell

discu.eu

"ghc-9.4.8.exe: could not detect mingw toolchain in the following paths:" - Problem when running ghci - discu.eu

Discussions and related articles for «"ghc-9.4.8.exe: could not detect mingw toolchain in the following paths:" - Problem when running ghci»

Jack Leightcap
@jleigh@recurse.social

Hey all! I'm due for an (re-)introduction: I'm Jack, an engineer in the NYC area from a firmware & cybersecurity background, currently working in something like hardware-software co-design.

Technical work is often with , and in all-too-rare moments stuff like and

I've never been much for social media, usually preferring to keep interests local: a better-detailed to follow as I figure this out 🙂

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared January 25, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared January 25, 2025

The readings shared in Bluesky on 25 January 2025 are Readings shared January 24, 2025. #ITP #IsabelleHOL #Haskell #FunctionalProgramming #AI #LLMs #GenerativeAI #NeuroSymbolicAI Pinpointing the lear

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared January 24, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared January 24, 2025

The readings shared in Bluesky on 24 January 2025 are Readings shared January 23, 2025. #ITP #IsabelleHOL #LeanProver #Python #Programming #Math #AI #LLMs Formally verified neurosymbolic trajectory l

Abhinav 🧭
@abnv@fantastic.earth

After seven years of meticulously formatting and aligning all the source code of my static site generator by hand, I finally moved to an auto-formatter today (Ormolu).

Screenshot of the summary of a git commit that says: Reformats Haskell code 66 changed files with 3201 additions and 2845 deletions
ALT text

Screenshot of the summary of a git commit that says: Reformats Haskell code 66 changed files with 3201 additions and 2845 deletions

Philipp :emacs: :nixos:
@pmidden@fosstodon.org

's "monoidmap" is fantastic! Getting a histogram from a list is just "foldMap (`MonoidMap.singleton` mempty)" (very implicit, using the "Sum" monoid)

Jencel Panic
@abuseofnotation@mathstodon.xyz

At the headquaters:

"OK, guys, so our user pool consists only of folks who already know and Is there a way to narrow it down more?"

"I got it, what if we allow unicode, so they also have to also know ?"

"Brilliant!"

(just kidding, agda is very cool (hope to learn it someday))

Jencel Panic
@abuseofnotation@mathstodon.xyz

At the headquaters:

"OK, guys, so our user pool consists only of folks who already know and Is there a way to narrow it down more?"

"I got it, what if we allow unicode, so they also have to also know ?"

"Brilliant!"

(just kidding, agda is very cool (hope to learn it someday))

Haskell Weekly
@haskell_discussions@mastodon.social

Hyperbole: Haskell interactive serverside web framework inspired by Htmx, Elm

github.com/seanhess/hyperbole

Discussions: discu.eu/q/https://github.com/

discu.eu

GitHub - seanhess/hyperbole: Haskell interactive serverside web framework inspired by HTMX, Elm, and Phoenix LiveView - discu.eu

Discussions and related articles for «GitHub - seanhess/hyperbole: Haskell interactive serverside web framework inspired by HTMX, Elm, and Phoenix LiveView»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared January 22, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared January 22, 2025

The readings shared in Bluesky on 22 January 2025 are Readings shared January 21, 2025. #ITP #Lean4 #IsabelleHOL #Math #Prolog #LogicProgramming #AI #LLMs #Exercitium: Iguales al siguiente. #Haskell

Haskell Weekly
@haskell_discussions@mastodon.social

A Proper x86 Assembler in Haskell Using the Escardó-Oliva Functional

blog.vmchale.com/article/escar

Discussions: discu.eu/q/http://blog.vmchale

discu.eu

A Proper X86 Assembler in Haskell Using the Escardó-Oliva Functional - discu.eu

Discussions and related articles for «A Proper X86 Assembler in Haskell Using the Escardó-Oliva Functional»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Advent of Code 2024: Haskell solution reflections for all 25 days. ~ Justin Le. blog.jle.im/entry/advent-of-co

blog.jle.im

Advent of Code 2024: Haskell Solution Reflections for all 25 Days

Admittedly a bit late, buuuuuut Merry belated Christmas and Happy New Years to all! This past December I again participated in Eric Wastl’s Advent of Code, a series of 25 daily Christmas-themed puzzles. Each puzzle comes with a cute story about saving Christmas, and the puzzles increase in difficulty as the stakes get higher and higher. Every night at midnight EST, my friends and I (including the good people of libera chat’s ##advent-of-code channel) discuss the latest puzzle and creative ways to solve and optimize it. But, the main goal isn’t to solve it quickly, it’s always to see creative ways to approach the puzzle and share different insights. The puzzles are bite-sized enough that there are often multiple ways to approach it, and in the past I’ve leveraged group theory, galilean transformations and linear algebra, and more group theory. This year was also the special 10 year anniversary event, with callbacks to fun story elements of all the previous years! Most of the puzzles are also pretty nice to solve in Haskell! Lots of DFS’s that melt away as simple recursion or recursion schemes, and even the BFS’s that expose you to different data structures and encodings. This year I’ve moved almost all of my Haskell code to an Advent of Code Megarepo. I also like to post write-ups on Haskelly ways to approach the problems, and they are auto-compiled on the megarepo wiki. I try my best every year, but sometimes I am able to complete write-ups for all 25 puzzles before the new year catches up. The last time was 2020, and I’m proud to announce that 2024 is now also 100% complete! You can find all of them here, but here are links to each individual one. Hopefully you can find them helpful. And if you haven’t yet, why not try Advent of Code yourself? :) And drop by the freenode ##advent-of-code channel, we’d love to say hi and chat, or help out! Thanks all for reading, and also thanks to Eric for a great event this year, as always!

Haskell Weekly
@haskell_discussions@mastodon.social

GHC String Interpolation Survey Open!

discourse.haskell.org/t/ghc-st

Discussions: discu.eu/q/https://discourse.h

discu.eu

GHC String Interpolation Survey Open! - Announcements - Haskell Community - discu.eu

Discussions and related articles for «GHC String Interpolation Survey Open! - Announcements - Haskell Community»

Haskell Weekly
@haskell_discussions@mastodon.social

Documentation on using Renovate with haskell-actions

github.com/haskell-actions/set

Discussions: discu.eu/q/https://github.com/

discu.eu

Documentation on using Renovate with haskell-actions · Issue #111 · haskell-actions/setup · GitHub - discu.eu

Discussions and related articles for «Documentation on using Renovate with haskell-actions · Issue #111 · haskell-actions/setup · GitHub»

WimⓂ️
@wim_v12e@merveilles.town

Minor annoyance of the day is this warning:

"warning: [GHC-63394] [-Wx-partial]
In the use of ‘head’
(imported from Prelude, but defined in GHC.List):
"This is a partial function, it throws an error on empty lists. Use pattern matching or Data.List.uncons instead. Consider refactoring to use Data.List.NonEmpty."

I don't want this is on by default. If I want to call `head` on a list it is my problem that this might fail.

Luckily, the fix is easy:

{-# OPTIONS_GHC -Wno-x-partial #-}

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared January 20, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared January 20, 2025

The readings shared in Bluesky on 20 January 2025 are Readings shared January 19, 2025. #ITP #LeanProver #FunctionalProgramming #Haskell #AI #LLMs #Exercitium: Primos consecutivos con media capicúa.

Haskell Weekly
@haskell_discussions@mastodon.social

SupGen is program synthesizer that outperforms SOTA alternatives using the HVM (which is now in Haskell!)

youtube.com/watch?v=GddkKIhDE2c

Discussions: discu.eu/q/https://www.youtube

discu.eu

SupGen is an AI-free program synthesizer based on examples or dependent types. It outperforms the SOTA by up to 1000x! - discu.eu

Discussions and related articles for «SupGen is an AI-free program synthesizer based on examples or dependent types. It outperforms the SOTA by up to 1000x!»

Abhinav 🧭
@abnv@fantastic.earth

Writing an for is almost a rite of passage for any programming language implementer, and it’s my turn now. In this post, I write not one but four Brainfuck in : abhinavsarkar.net/posts/brainf

Please boost for reach. If you have any questions or comments, please reply to this post.

abhinavsarkar.net

Interpreting Brainfuck in Haskell

We write a few Brainfuck interpreters in Haskell.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared January 18, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared January 18, 2025

The readings shared in Bluesky on 18 January 2025 are Readings shared January 17, 2025. #Haskell #Python #ITP #Coq #Rocq #LeanProver #Logic #Math #AI #LLMs #Reasoning #Exercitium: Mastermind. #Haske

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared January 17, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared January 17, 2025

The readings shared in Bluesky on 17 January 2025 are Readings shared January 16, 2025. #ITP #LeanProver #Agda #Logic #Math #SAT #SMT #FunctionalProgramming #Haskell #Python #Matemáticas #AI #LLMs #E

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

: Determinación de los elementos minimales. jaalonso.github.io/exercitium/

jaalonso.github.io

Determinación de los elementos minimales

Definir la función minimales :: Ord a => [[a]] -> [[a]] tal que (minimales xss) es la lista de los elementos de xss que no están contenidos en otros elementos de xss. Por ejemplo, minimales [[1,3],[

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

: Research software engineer at Epic. tinyurl.com/23jucqu4

discourse.haskell.org

Research Software Engineer at Epic

The Verse research group at Epic Games, of which I am a member, is looking for a research software engineer to join the team. By way of context we are designing a new and rather unusual programming language called Verse. Verse is a functional logic language, with a distinctive and highly expressive type system. It is the language in which game designers and myriad other uses of the Unreal engine will give behaviour and life to their virtual realities. You can find a paper about it here. The jo...

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared January 16, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared January 16, 2025

The readings shared in Bluesky on 16 January 2025 are Readings shared January 15, 2025. #ITP #LeanProver #Logic #Math #CompSci #FunctionalProgramming #Haskell #Exercitium: Sucesión de números amigos.

Haskell Weekly
@haskell_discussions@mastodon.social

Now added initial support for Haskell - auto-generate Haskell data models from Scala case classes - early preview, will extend further in hackathon

codeberg.org/jjba23/dmtscala

Discussions: discu.eu/q/https://codeberg.or

discu.eu

jjba23/dmtscala: WIP: Parse and translate Scala data models into several programming languages - Codeberg.org - discu.eu

Discussions and related articles for «jjba23/dmtscala: WIP: Parse and translate Scala data models into several programming languages - Codeberg.org»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

: Suma de los números amigos menores que n. jaalonso.github.io/exercitium/

jaalonso.github.io

Suma de los números amigos menores que n

Dos números amigos son dos números enteros positivos distintos tales que la suma de los divisores propios de cada uno es igual al otro. Los divisores propios de un número incluyen la unidad pero no al

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

The Haskell Unfolder Episode 38: tasting and testing CUDA (map, fold, scan). ~ Edsko de Vries, Andres Löh. youtube.com/live/ww4C3jlsesw?s

youtube.com

The Haskell Unfolder Episode 38: tasting and testing CUDA (map, fold, scan)

CUDA is an extension of C for programming NVIDIA GPUs. In this episode of the Haskell Unfolder we show how to set up a CUDA library so that we can link to it...

Lira :progresspride_i_flag:
@LiraK@tech.lgbt

:boosts_ok_gay: lira.kraamwinkel.be/articles/h

A while ago I wrote about the Foreign Function Interface in Haskell and how to make a desktop application with Qt6.

The following topics are covered:

  • Using foreign import to call C or C++-functions (without name mangling);
  • Using foreign export to call Haskell-functions in C or C++
  • How to create pointers that get freed automatically to prevent memory issues;
  • How to create arrays in Haskell;
  • How to create structs in Haskell (manually and via GStorable);
  • How to create function pointers in Haskell;
  • Why MonadReader (IORef [a]) m is better for storing pointers than MonadState [a] m;
  • The difference between ccall and capi

I already shared it on my previous account back then, but I am posting it here now too :)

Haskell Weekly
@haskell_discussions@mastodon.social

The Haskell Unfolder Episode 38: tasting and testing CUDA (map, fold, scan)

youtube.com/watch?index=38&lis

Discussions: discu.eu/q/https://www.youtube

discu.eu

The Haskell Unfolder Episode 38: tasting and testing CUDA (map, fold, scan) - YouTube - discu.eu

Discussions and related articles for «The Haskell Unfolder Episode 38: tasting and testing CUDA (map, fold, scan) - YouTube»

Lira :progresspride_i_flag:
@LiraK@tech.lgbt

:boosts_ok_gay: lira.kraamwinkel.be/articles/h

A while ago I wrote about the Foreign Function Interface in Haskell and how to make a desktop application with Qt6.

The following topics are covered:

  • Using foreign import to call C or C++-functions (without name mangling);
  • Using foreign export to call Haskell-functions in C or C++
  • How to create pointers that get freed automatically to prevent memory issues;
  • How to create arrays in Haskell;
  • How to create structs in Haskell (manually and via GStorable);
  • How to create function pointers in Haskell;
  • Why MonadReader (IORef [a]) m is better for storing pointers than MonadState [a] m;
  • The difference between ccall and capi

I already shared it on my previous account back then, but I am posting it here now too :)

Andres Löh
@kosmikus@functional.cafe

The is back! In tomorrow's episode, we'll take a look at CUDA and write some simple functions in it. We'll also show how to interface from Haskell to CUDA and how to use QuickCheck to test CUDA functions from Haskell.

youtube.com/watch?v=ww4C3jlses

youtube.com

The Haskell Unfolder Episode 38: tasting and testing CUDA (map, fold, scan)

CUDA is an extension of C for programming NVIDIA GPUs. In this episode of the Haskell Unfolder we show how to set up a CUDA library so that we can link to it...

Lionhairdino
@lionhairdino@mastodon.social

하스켈 공부를 시작하고, 펑터를 슬슬 쓰기 시작하면서, Applicative 로 넘어갈 무렵에 볼만한 글입니다. 컨텍스트란 말이 편해지면, 펑터 다음 진도에 도움이 많이 됩니다.

최근 펑터를 공부하면서, 펑터가 달리 보여 5년전 글의 컨텍스트, Applicative, Traversable 내용을 보강해 봤습니다.

lionhairdino.github.io/posts/2

lionhairdino.github.io

컨텍스트, Applicative 펑터, Traversable

맥락같은 모호한 설명을 하려는 문서가 아닙니다. 하스켈 펑터에서 컨텍스트는 펑터 타입에 접근할 때 항상 동작하는 코드를 의미합니다.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared January 11, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared January 11, 2025

The readings shared in Bluesky on 11 January 2025 are Readings shared January 10, 2025. #ITP #LeanProver #Logic #Math #Haskell #Python #ASP #LogicProgramming #AI #NeuroSymbolicAI #LLMs #Exercitium: N

Lionhairdino
@lionhairdino@mastodon.social

예전 펑터 글에 "펑터 값을 프리미티브한 값처럼 쓰고 싶다"라는 목표를 먼저 세우고, `<$>`와 `<*>`등을 살펴보는 내용을 추가했습니다.
lionhairdino.github.io/posts/2

lionhairdino.github.io

한 번쯤 나올 법 했는데, 아직 없었던 펑터 이야기

수학에서 말하는 펑터가 하스켈에 어떤 모양, 어떤 이유로 들어왔는지 상상해본 글입니다.

DiazCarrete
@DiazCarrete@hachyderm.io

Trying to learn persistent/esqueleto

yesodweb.com/book/persistent

hackage.haskell.org/package/pe
persistent-postgresql hackage.haskell.org/package/pe
the Persistent entity syntax hackage.haskell.org/package/pe
esqueleto hackage.haskell.org/package/es

Screen capture from the Yesod book. However, there is one issue that newcomers are often bothered by: why are IDs and values completely separate? It seems like it would be very logical to embed the ID inside the value. In other words, instead of having: data Person = Person { name :: String } have data Person = Person { personId :: PersonId, name :: String } Well, there’s one problem with this right off the bat: how do we do an insert? If a Person needs to have an ID, and we get the ID by inserting, and an insert needs a Person, we have an impossible loop. We could solve this with undefined, but that’s just asking for trouble.
ALT text

Screen capture from the Yesod book. However, there is one issue that newcomers are often bothered by: why are IDs and values completely separate? It seems like it would be very logical to embed the ID inside the value. In other words, instead of having: data Person = Person { name :: String } have data Person = Person { personId :: PersonId, name :: String } Well, there’s one problem with this right off the bat: how do we do an insert? If a Person needs to have an ID, and we get the ID by inserting, and an insert needs a Person, we have an impossible loop. We could solve this with undefined, but that’s just asking for trouble.

"One last trick you can do with attributes is to specify the names to be used for the SQL tables and columns. This can be convenient when interacting with existing databases."
ALT text

"One last trick you can do with attributes is to specify the names to be used for the SQL tables and columns. This can be convenient when interacting with existing databases."

Lionhairdino
@lionhairdino@mastodon.social

예전 펑터 글에 "펑터 값을 프리미티브한 값처럼 쓰고 싶다"라는 목표를 먼저 세우고, `<$>`와 `<*>`등을 살펴보는 내용을 추가했습니다.
lionhairdino.github.io/posts/2

lionhairdino.github.io

한 번쯤 나올 법 했는데, 아직 없었던 펑터 이야기

수학에서 말하는 펑터가 하스켈에 어떤 모양, 어떤 이유로 들어왔는지 상상해본 글입니다.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared January 10, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared January 10, 2025

The readings shared in Bluesky on 10 January 2025 are Readings shared January 9, 2025. #ITP #LeanProver #Logic #Math #FunctionalProgramming #Haskell #JavaScript #Python #AI #NeuralNetwork #ChatGPT #

Haskell Weekly
@haskell_discussions@mastodon.social

[ANN] Yolc - a Haskell-powered, safe, expressive, fun language for Ethereum

discourse.haskell.org/t/ann-yo

Discussions: discu.eu/q/https://discourse.h

discu.eu

[ANN] Yolc - a Haskell-powered, safe, expressive, fun language for Ethereum - discu.eu

Discussions and related articles for «[ANN] Yolc - a Haskell-powered, safe, expressive, fun language for Ethereum»

Haskell Weekly
@haskell_discussions@mastodon.social

Unable to build botan

github.com/haskell-cryptograph

Discussions: discu.eu/q/https://github.com/

discu.eu

GitHub - haskell-cryptography/botan: Haskell bindings for the Botan cryptography library - discu.eu

Discussions and related articles for «GitHub - haskell-cryptography/botan: Haskell bindings for the Botan cryptography library»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared January 9, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared January 9, 2025

The readings shared in Bluesky on 9 January 2025 are Readings shared January 8, 2025. #ITP #IsabelleHOL #AI #MachineLearning #LLMs Teaching "Foundations of mathematics" with the LEAN theorem prover.

Haskell Weekly
@haskell_discussions@mastodon.social

Case Study — Using a JavaScript component inside a Haskell application

blog.haskell.org/case-study-fo

Discussions: discu.eu/q/https://blog.haskel

discu.eu

Case Study — Using a JavaScript component inside a Haskell application | The Haskell Programming Language's blog - discu.eu

Discussions and related articles for «Case Study — Using a JavaScript component inside a Haskell application | The Haskell Programming Language's blog»

Jons Mostovojs
@jonn@social.doma.dev · Reply to Jons Mostovojs

@tolmasky if I had to implement reflection in Lean4 or Agda, I would try to mimic 's typeable.

But also, I think there must be a very important point here! In dependently typed languages, entities can have more than one type!

(frac 1 2) : Frac 2 4, but also (frac 1 2) : Frac 4 8, for instance.

[1] : ListLE 1, but also [1]: ListLE 42.

So, perhaps the whole idea of general reflaction is defeated by this property. And this is why offers superior reflection[1]. Note that is in itself!

I don't know if I'm mansplaining here or if you're aware of haskell's Typeable, but here is a simple demo of its capabilities: github.com/cognivore/typeable-

In , I would emulate it by defining asking the user to provide explict instances over an enum, just as you wrote! The existential quantification trick can be done in by carrying the instance inside a structure that ties the knot between the type and an entity which has this type:

```
structure Stuff where
α : Type
val : α
inst : Reflect α
```

You won't be able to construct it unless α is Reflect.

* * *

[1]: hackage.haskell.org/package/ba

hackage.haskell.org

Type.Reflection

DescriptionThis provides a type-indexed type representation mechanism, similar to that described by,Simon Peyton-Jones, Stephanie Weirich, Richard Eisenberg, Dimitrios Vytiniotis. "A reflection on types". Proc. Philip Wadler's 60th birthday Festschrift, Edinburgh (April 2016).The interface provides TypeRep, a type representation which can be safely decomposed and composed. See Data.Dynamic for an example of this.Since: base-4.10.0.0

Abhinav 🧭
@abnv@fantastic.earth

In my quest of solving problems in interesting ways, this time I solved the 2020 problem "Seating System" with comonads and stencils in . Read my latest post about it: abhinavsarkar.net/posts/solvin

abhinavsarkar.net

Solving Advent of Code “Seating System” with Comonads and Stencils

We solve the Advent of Code 2020 “Seating System” challenge in Haskell using comonads and stencils.

Haskell Weekly
@haskell_discussions@mastodon.social

Solving Advent of Code “Seating System” with Comonads and Stencils

abhinavsarkar.net/posts/solvin

Discussions: discu.eu/q/https://abhinavsark

discu.eu

Solving Advent of Code “Seating System” with Comonads and Stencils | abhinavsarkar.net - discu.eu

Discussions and related articles for «Solving Advent of Code “Seating System” with Comonads and Stencils | abhinavsarkar.net»

Ava
@faelif@mathstodon.xyz

post on this new instance

Hello! I'm Ava, also known as faelif. I'm 18 and I'm studying for my A-levels here in the (double , and ). I program in and am learning . I'm but I don't really feel connected with gender at all.

I'm interested in , more broadly, , , , , and .

I used to be on the fediverse @faelif@mastodon.social. You can also find me on Bookwyrm @faelif@bookwyrm.social.

Haskell Weekly
@haskell_discussions@mastodon.social

Policy regarding taking over Hackage packages

discourse.haskell.org/t/policy

Discussions: discu.eu/q/https://discourse.h

discu.eu

Policy regarding taking over Hackage packages - Haskell Community - discu.eu

Discussions and related articles for «Policy regarding taking over Hackage packages - Haskell Community»

Abhinav 🧭
@abnv@fantastic.earth

In my quest of solving problems in interesting ways, this time I solved the 2020 problem "Seating System" with comonads and stencils in . Read my latest post about it: abhinavsarkar.net/posts/solvin

abhinavsarkar.net

Solving Advent of Code “Seating System” with Comonads and Stencils

We solve the Advent of Code 2020 “Seating System” challenge in Haskell using comonads and stencils.

Abhinav 🧭
@abnv@fantastic.earth

In my quest of solving problems in interesting ways, this time I solved the 2020 problem "Seating System" with comonads and stencils in . Read my latest post about it: abhinavsarkar.net/posts/solvin

abhinavsarkar.net

Solving Advent of Code “Seating System” with Comonads and Stencils

We solve the Advent of Code 2020 “Seating System” challenge in Haskell using comonads and stencils.

Lionhairdino
@lionhairdino@mastodon.social

a는 Identity a라고 본다면, 세상의 모든 값을 펑터 값으로 생각할 수 있습니다. 항상 함수를 적용할 때는 f <$> a라 쓸 수 있습니다. 간단한 프리미티브 값이든, 복잡한 계산 후 받는 값이든 모두 같은 것으로 취급할 수 있습니다.

FRP에서 Event, Behavior를 일반 값처럼 쓰기 위해, 특별한 테크닉이 필요하지 않습니다. 원래 펑터가 그런 것입니다.

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared January 3, 2025. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared January 3, 2025

The readings shared in Bluesky on 3 January 2025 are Readings shared January 2, 2025. #Haskell #Python #Math #Exercitium: Mayor órbita de la sucesión de Collatz. #Haskell #Python #Matemáticas Proofs

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

: Mayor órbita de la sucesión de Collatz. jaalonso.github.io/exercitium/

jaalonso.github.io

Mayor órbita de la sucesión de Collatz

Se considera la siguiente operación, aplicable a cualquier número entero positivo: Si el número es par, se divide entre 2. Si el número es impar, se multiplica por 3 y se suma 1. Dado un número cual

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Modular probabilistic programming with algebraic effects. ~ Oliver Goldstein, Ohad Kammar. arxiv.org/abs/2412.19826

arxiv.org

Modular probabilistic programming with algebraic effects (MSc Thesis 2019)

Probabilistic programming languages, which exist in abundance, are languages that allow users to calculate probability distributions defined by probabilistic programs, by using inference algorithms. However, the underlying inference algorithms are not implemented in a modular fashion, though, the algorithms are presented as a composition of other inference components. This discordance between the theory and the practice of Bayesian machine learning, means that reasoning about the correctness of probabilistic programs is more difficult, and composing inference algorithms together in code may not necessarily produce correct compound inference algorithms. In this dissertation, I create a modular probabilistic programming library, already a nice property as its not a standalone language, called Koka Bayes, that is based off of both the modular design of Monad Bayes -- a probabilistic programming library developed in Haskell -- and its semantic validation. The library is embedded in a recently created programming language, Koka, that supports algebraic effect handlers and expressive effect types -- novel programming abstractions that support modular programming. Effects are generalizations of computational side-effects, and it turns out that fundamental operations in probabilistic programming such as probabilistic choice and conditioning are instances of effects.

Haskell Weekly
@haskell_discussions@mastodon.social

[Design] Dataframes in Haskell

discourse.haskell.org/t/design

Discussions: discu.eu/q/https://discourse.h

discu.eu

[Design] Dataframes in Haskell - #2 - Haskell Foundation - Haskell Community - discu.eu

Discussions and related articles for «[Design] Dataframes in Haskell - #2 - Haskell Foundation - Haskell Community»

Haskell Weekly
@haskell_discussions@mastodon.social

erebe/greenclip: Simple clipboard manager to be integrated with rofi

github.com/erebe/greenclip

Discussions: discu.eu/q/https://github.com/

discu.eu

GitHub - erebe/greenclip: Simple clipboard manager to be integrated with rofi - Static binary available - discu.eu

Discussions and related articles for «GitHub - erebe/greenclip: Simple clipboard manager to be integrated with rofi - Static binary available»

Haskell Weekly
@haskell_discussions@mastodon.social

Exported for tests only: Precise control over API visibility with custom warnings

tech.scrive.com/exported-for-t

Discussions: discu.eu/q/https://tech.scrive

discu.eu

Exported for tests only: Precise control over API visibility with custom warnings - discu.eu

Discussions and related articles for «Exported for tests only: Precise control over API visibility with custom warnings»

José A. Alonso
@Jose_A_Alonso@mathstodon.xyz

Readings shared December 30, 2024. jaalonso.github.io/vestigium/p

jaalonso.github.io

Readings shared December 30, 2024

The readings shared in Bluesky on 30 December 2024 are Readings shared December 29, 2024. #Haskell #Python #Math #AI #ITP Formal verification of a custom scheduling algorithm and specification of a R

Lionhairdino
@lionhairdino@mastodon.social

크리스마스에는 모나드 를 봅시다.
lionhairdino.github.io/posts/2

lionhairdino.github.io

크리스마스에는 모나드지

모노이드 구조를 먼저 살펴보고, 어떤 구조를 모나드라 부르는지 수학없이 풀어 봤습니다. 용어가 일단 수학 용어이긴 하지만, 최대한 실무에서 보이는 모양으로 풀었습니다.