# Haskell

Haskell is a purely functional programming language with static typing, type inference, and lazy evaluation.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Longtail-SWE: High-Quality SWE Tasks for Underrepresented Languages

DevFeed: [Longtail-SWE: High-Quality SWE Tasks for Underrepresented Languages](<https://devfeed.tech/articles/longtail-swe-high-quality-swe-tasks-for-underrepresented-languages-125913.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.10304>)

Author: Vladimir Dobrovolskii, Ibragim Badertdinov, Alexander Golubev

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Benchmark](<https://devfeed.tech/topics/benchmark.md>), [Erlang](<https://devfeed.tech/topics/erlang.md>), [Haskell](<https://devfeed.tech/topics/haskell.md>), [IntelliJ IDEA](<https://devfeed.tech/topics/intellij-idea.md>), [The Julia Language](<https://devfeed.tech/topics/julia.md>), [Swift](<https://devfeed.tech/topics/swift.md>), [Frontier AI](<https://devfeed.tech/topics/frontier-ai.md>)

Tags: [benchmark](<https://devfeed.tech/tags/benchmark.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [programming-language](<https://devfeed.tech/tags/programming-language.md>), [quality](<https://devfeed.tech/tags/quality.md>), [tasks](<https://devfeed.tech/tags/tasks.md>)

### AI overview

Longtail-SWE provides 202 repository-level issue-resolution tasks across 13 languages with limited representation in existing benchmarks. To vet candidates without discarding challenging problems, its solver-judge-repairer pipeline has a solver attempt each task, then a judge review the task, solver trajectory, and test results to guide repairs to tests and descriptions. The revisions target tests that reject valid alternatives or accept incorrect solutions while preserving task requirements. The authors evaluate nine model configurations, including frontier models, on solving performance, consistency across repeated attempts, and resource use. They release the tasks, executable environments, construction and evaluation tools, agent trajectories, and an easier task set for smaller models.

### Source excerpt

arXiv:2611.10304v1 Announce Type: cross Abstract: Challenging repository-level benchmarks remain limited for many programming language ecosystems, where filtering scarce candidates with ambiguous descriptions or defective tests can discard valuable engineering problems. We introduce Longtail-SWE, a benchmark of 202 issue-resolution tasks across 13 languages with limited coverage in existing repository-level benchmarks: Clojure, Dart, Elixir, Erlang, F#, Haskell, Julia, Kotlin, Lua, OCaml, R, Scala, and Swift. Its construction uses a solver--judge--repairer pipeline: a solver attempts each candidate task, and a judge reviews the task together with the solver's trajectory and test results to guide revisions to tests and task descriptions. These revisions aim to correct tests that reject valid alternative implementations or accept incorrect solutions while retaining challenging tasks and preserving their intended requirements. We evaluate nine model configurations, including frontier models, and analyze task-solving performance, consistency across repeated attempts, and resource usage. We release all benchmark instances, executable environments, complete construction and evaluation tooling, and agent trajectories, together with an additional set of easier tasks to support evaluation of smaller models.

## PL/Haskell v6.0 Released

DevFeed: [PL/Haskell v6.0 Released](<https://devfeed.tech/articles/pl-haskell-v6-0-released-61373.md>)

Original publisher: [Read original article](<https://www.postgresql.org/about/news/plhaskell-v60-released-3388/>)

Author: PL; Haskell

Published: 2026-09-28T00:00:00Z

Content type: release

Language: en

Sources: [PostgreSQL news](<https://devfeed.tech/sources/postgresql-news.md>)

Topics: [Haskell](<https://devfeed.tech/topics/haskell.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>)

Tags: [ghc](<https://devfeed.tech/tags/ghc.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>)

### AI overview

PL/Haskell 6.0 adds support for working with range types when writing PostgreSQL functions in Haskell. The announcement describes package availability for Ubuntu and Fedora and points Fedora 44 users to a workaround for a bug in GHC libraries.

### Source excerpt

We are pleased to announce the release of version 6.0 of the PL/Haskell extension. This extension allows users to write PostgreSQL functions in the Haskell functional programming language. Instructions can be found here. Version 6.0 adds the ability to work with range types. Users of Ubuntu and Fedora can install the extension directly from the rpm and apt repositories. Please note that these is a bug in the GHC libraries in Fedora 44. If you are using Fedora 44, see the workaround. If you have problems with the extension or a feature request, please submit a Github issue.

## DrvGraph: Display unbuilt or unfetched store paths before building your packages

DevFeed: [DrvGraph: Display unbuilt or unfetched store paths before building your packages](<https://devfeed.tech/articles/drvgraph-display-unbuilt-or-unfetched-store-paths-before-building-your-packages-55533.md>)

Original publisher: [Read original article](<https://discourse.nixos.org/t/drvgraph-display-unbuilt-or-unfetched-store-paths-before-building-your-packages/80165>)

Author: oo-infty

Published: 2026-09-20T11:41:56Z

Content type: article

Language: en

Sources: [Announcements - NixOS Discourse](<https://devfeed.tech/sources/announcements-nixos-discourse.md>)

Topics: [Nix](<https://devfeed.tech/topics/nix.md>), [Graphs](<https://devfeed.tech/topics/graphs.md>), [Haskell](<https://devfeed.tech/topics/haskell.md>)

Tags: [announcements](<https://devfeed.tech/tags/announcements.md>), [dependency-graph](<https://devfeed.tech/tags/dependency-graph.md>), [github](<https://devfeed.tech/tags/github.md>), [haskell](<https://devfeed.tech/tags/haskell.md>), [nix](<https://devfeed.tech/tags/nix.md>), [project](<https://devfeed.tech/tags/project.md>)

### AI overview

DrvGraph is a Haskell-based visualizer for unbuilt Nix package derivations. It traverses a package's dependency graph and presents the store paths that would need to be built or fetched before building, allowing users to preview the graph in advance.

### Source excerpt

DrvGraph is a derivation graph visualizer for unbuilt Nix package, which traverses and analyzes the dependency graph of a Nix package, and then show what needs to be built or fetched in a tree representation. So you can know those unbuilt or unfetched store paths in advance without actually building your package. This is my first Haskell project and I really learnt a lot when developing it. I hope you will enjoy it. Any feedbacks and contributions are highly appreciated. github.com GitHub - StarryReverie/DrvGraph: Derivation graph visualizer for unbuilt Nix... Derivation graph visualizer for unbuilt Nix package 4 posts - 2 participants Read full topic

## Code Style and Quality Guide -- Scala

DevFeed: [Code Style and Quality Guide -- Scala](<https://devfeed.tech/articles/code-style-and-quality-guide-scala-48568.md>)

Original publisher: [Read original article](<https://flink.apache.org/how-to-contribute/code-style-and-quality-scala/>)

Published: 2026-09-18T15:54:07.612713Z

Content type: tutorial

Language: en

Sources: [Apache Flink](<https://devfeed.tech/sources/apache-flink-stateful-computations-over-data-streams-on-apache-flink.md>)

Topics: [Haskell](<https://devfeed.tech/topics/haskell.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>), [Apache Flink](<https://devfeed.tech/topics/apache-flink.md>), [code style](<https://devfeed.tech/topics/code-style.md>), [Code](<https://devfeed.tech/topics/code.md>), [Java](<https://devfeed.tech/topics/java.md>)

Tags: [code-quality](<https://devfeed.tech/tags/code-quality.md>), [code-style](<https://devfeed.tech/tags/code-style.md>), [flink](<https://devfeed.tech/tags/flink.md>), [java](<https://devfeed.tech/tags/java.md>), [libraries](<https://devfeed.tech/tags/libraries.md>), [quality](<https://devfeed.tech/tags/quality.md>), [scala](<https://devfeed.tech/tags/scala.md>)

### AI overview

A Scala code style and quality guide for the Apache Flink project. It explains where Scala is used, how Scala and Java APIs should remain aligned, and which language features and practices contributors should follow.

### Source excerpt

Code Style and Quality Guide -- Scala # Preamble # Pull Requests & Changes # Common Coding Guide # Java Language Guide # Scala Language Guide # Components Guide # Formatting Guide # Scala Language Features # Where to use (and not use) Scala # We use Scala for Scala APIs or pure Scala Libraries. We do not use Scala in the core APIs and runtime components. We aim to remove existing Scala use (code and dependencies) from those components.

## Profunctor Optics

DevFeed: [Profunctor Optics](<https://devfeed.tech/articles/profunctor-optics-28864.md>)

Original publisher: [Read original article](<https://bartoszmilewski.com/2026/07/19/profunctor-optics/>)

Author: Bartosz Milewski

Published: 2026-07-19T11:39:02Z

Content type: article

Language: en

Sources: [Bartosz Milewski's Programming Cafe](<https://devfeed.tech/sources/bartosz-milewski-s-programming-cafe.md>)

Topics: [Haskell](<https://devfeed.tech/topics/haskell.md>), [Programming language](<https://devfeed.tech/topics/programming-language.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [modules](<https://devfeed.tech/topics/modules.md>)

Tags: [category-theory](<https://devfeed.tech/tags/category-theory.md>), [haskell](<https://devfeed.tech/tags/haskell.md>), [language](<https://devfeed.tech/tags/language.md>), [lens](<https://devfeed.tech/tags/lens.md>), [mapping](<https://devfeed.tech/tags/mapping.md>), [modules](<https://devfeed.tech/tags/modules.md>), [optics](<https://devfeed.tech/tags/optics.md>), [profunctors](<https://devfeed.tech/tags/profunctors.md>), [programming-language](<https://devfeed.tech/tags/programming-language.md>), [tambara-modules](<https://devfeed.tech/tags/tambara-modules.md>)

### AI overview

This article explains profunctor optics through Tannakian reconstruction. It presents optics as a category, describes lenses and their composition in Haskell, and introduces Tambara modules as a representation that simplifies optic composition.

### Source excerpt

You may think of Tannakian Reconstruction as an example of redundant encoding. It lets you replace a simple hom-set with a much more complex end that is taken over an entire functor category. Why would anyone want to do it? The answer is simple: composition! Morphisms on the left compose according to the rules of [...]

## Tambara Equipment

DevFeed: [Tambara Equipment](<https://devfeed.tech/articles/tambara-equipment-28862.md>)

Original publisher: [Read original article](<https://bartoszmilewski.com/2026/07/11/tambara-equipment/>)

Author: Bartosz Milewski

Published: 2026-07-11T08:13:34Z

Content type: article

Language: en

Sources: [Bartosz Milewski's Programming Cafe](<https://devfeed.tech/sources/bartosz-milewski-s-programming-cafe.md>)

Topics: [modules](<https://devfeed.tech/topics/modules.md>), [Haskell](<https://devfeed.tech/topics/haskell.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [category-theory](<https://devfeed.tech/tags/category-theory.md>), [code](<https://devfeed.tech/tags/code.md>), [double-categories](<https://devfeed.tech/tags/double-categories.md>), [double-category](<https://devfeed.tech/tags/double-category.md>), [haskell](<https://devfeed.tech/tags/haskell.md>), [modules](<https://devfeed.tech/tags/modules.md>), [optics](<https://devfeed.tech/tags/optics.md>), [proarrow-equipment](<https://devfeed.tech/tags/proarrow-equipment.md>), [profunctors](<https://devfeed.tech/tags/profunctors.md>), [structure](<https://devfeed.tech/tags/structure.md>), [tambara-modules](<https://devfeed.tech/tags/tambara-modules.md>), [tannakian-reconstruction](<https://devfeed.tech/tags/tannakian-reconstruction.md>), [theory](<https://devfeed.tech/tags/theory.md>), [transformation](<https://devfeed.tech/tags/transformation.md>)

### AI overview

This article explains Tambara modules through category theory and illustrates the concepts with Haskell code. It discusses their relationship to profunctors, monoidal actions, double categories, proarrow equipment, and Tannakian reconstruction.

### Source excerpt

I was originally attracted to category theory when trying to understand Haskell optics. I was puzzled by the van Laarhoven's functor representations and Kmett's use of Tambara modules. By playing Tetris with the Yoneda lemma I was able to make some progress, attacking more and more esoteric topics. With a group of researcher and students [...]

## Actegories

DevFeed: [Actegories](<https://devfeed.tech/articles/actegories-28861.md>)

Original publisher: [Read original article](<https://bartoszmilewski.com/2026/06/30/actegories/>)

Author: Bartosz Milewski

Published: 2026-06-30T11:45:46Z

Content type: tutorial

Language: en

Sources: [Bartosz Milewski's Programming Cafe](<https://devfeed.tech/sources/bartosz-milewski-s-programming-cafe.md>)

Topics: [Programming](<https://devfeed.tech/topics/programming.md>), [Haskell](<https://devfeed.tech/topics/haskell.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [actegories](<https://devfeed.tech/tags/actegories.md>), [category-theory](<https://devfeed.tech/tags/category-theory.md>), [class](<https://devfeed.tech/tags/class.md>), [haskell](<https://devfeed.tech/tags/haskell.md>), [lens](<https://devfeed.tech/tags/lens.md>), [optics](<https://devfeed.tech/tags/optics.md>), [programming](<https://devfeed.tech/tags/programming.md>), [types](<https://devfeed.tech/tags/types.md>)

### AI overview

This tutorial introduces actegories, explaining their relationship to monoidal categories and their role in programming optics such as lenses, prisms, and traversals. It develops the concepts through Haskell models, including tensor products, unit objects, constraints, associators, unitors, and categorical actions.

### Source excerpt

Previously: Kan Extensions in Double Categories. In programming, actegories play a central role in optics: lenses, prisms, traversals, etc. To understand actegories, let's start with the definition of a monoidal category. Monoidal Category A monoidal category is a category equipped with a tensor product. A tensor product is a functor . We assume that this [...]

## Kan Extensions in Double Categories

DevFeed: [Kan Extensions in Double Categories](<https://devfeed.tech/articles/kan-extensions-in-double-categories-28860.md>)

Original publisher: [Read original article](<https://bartoszmilewski.com/2026/06/13/kan-extensions-in-double-categories/>)

Author: Bartosz Milewski

Published: 2026-06-13T12:27:28Z

Content type: article

Language: en

Sources: [Bartosz Milewski's Programming Cafe](<https://devfeed.tech/sources/bartosz-milewski-s-programming-cafe.md>)

Topics: [Haskell](<https://devfeed.tech/topics/haskell.md>), [data type](<https://devfeed.tech/topics/data-type.md>), [implementation](<https://devfeed.tech/topics/implementation.md>)

Tags: [category-theory](<https://devfeed.tech/tags/category-theory.md>), [data-type](<https://devfeed.tech/tags/data-type.md>), [double-category](<https://devfeed.tech/tags/double-category.md>), [function](<https://devfeed.tech/tags/function.md>), [haskell](<https://devfeed.tech/tags/haskell.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [kan-extensions](<https://devfeed.tech/tags/kan-extensions.md>), [profunctor-equipment](<https://devfeed.tech/tags/profunctor-equipment.md>), [profunctors](<https://devfeed.tech/tags/profunctors.md>)

### AI overview

This article generalizes right and left Kan extensions from functors to profunctors in double categories and presents corresponding Haskell representations. It explains the associated universal and factorization properties, including their computational interpretation.

### Source excerpt

Previously: Kan extensions in Haskell. In a double category that is also a proarrow equipment, we have the ability to bend arrows. In particular, in the definition of the counit of the right Kan extension: we can bend the vertical arrow, replacing it with its horizontal conjoint . In a profunctor equipment, this is just [...]

## Kan Extensions in Haskell

DevFeed: [Kan Extensions in Haskell](<https://devfeed.tech/articles/kan-extensions-in-haskell-28859.md>)

Original publisher: [Read original article](<https://bartoszmilewski.com/2026/06/08/kan-extensions-in-haskell/>)

Author: Bartosz Milewski

Published: 2026-06-08T12:31:58Z

Content type: tutorial

Language: en

Sources: [Bartosz Milewski's Programming Cafe](<https://devfeed.tech/sources/bartosz-milewski-s-programming-cafe.md>)

Topics: [Haskell](<https://devfeed.tech/topics/haskell.md>), [Reflex FRP](<https://devfeed.tech/topics/reflex-frp.md>)

Tags: [building](<https://devfeed.tech/tags/building.md>), [category-theory](<https://devfeed.tech/tags/category-theory.md>), [extensions](<https://devfeed.tech/tags/extensions.md>), [haskell](<https://devfeed.tech/tags/haskell.md>), [kan-extensions](<https://devfeed.tech/tags/kan-extensions.md>), [programming](<https://devfeed.tech/tags/programming.md>), [types](<https://devfeed.tech/tags/types.md>), [universal-arrows](<https://devfeed.tech/tags/universal-arrows.md>)

### AI overview

This article explains Kan extensions in category theory and translates their definitions and constructions into Haskell. It focuses on right Kan extensions, adjunctions, universal arrows, and pointwise constructions.

### Source excerpt

Previously: Tabulation Tribulations. If you think of functor composition as a form of multiplication, Kan extensions are an attempt to construct inverses of this multiplication. But unlike multiplication, composition is not symmetric, so we have extensions that attempt to undo precomposition, and lifts that do the same for postcomposition. Furthermore, there rarely is a single [...]

## Simon Peyton Jones on Haskell and Why Functional Programming Matters

DevFeed: [Simon Peyton Jones on Haskell and Why Functional Programming Matters](<https://devfeed.tech/articles/co-creator-of-haskell-functional-programming-thinking-in-types-useless-languages-simon-jones-18084.md>)

Original publisher: [Read original article](<https://www.developing.dev/p/co-creator-of-haskell-functional>)

Author: Ryan Peterman

Published: 2026-06-08T10:02:31Z

Content type: article

Language: en

Sources: [The Developing Dev](<https://devfeed.tech/sources/the-developing-dev.md>)

Topics: [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Haskell](<https://devfeed.tech/topics/haskell.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Declarative programming](<https://devfeed.tech/topics/declarative-programming.md>), [Programming language](<https://devfeed.tech/topics/programming-language.md>)

Tags: [declarative](<https://devfeed.tech/tags/declarative.md>), [functional-programming](<https://devfeed.tech/tags/functional-programming.md>), [languages](<https://devfeed.tech/tags/languages.md>), [programming](<https://devfeed.tech/tags/programming.md>), [programming-language](<https://devfeed.tech/tags/programming-language.md>), [types](<https://devfeed.tech/tags/types.md>)

### AI overview

An interview with Simon Peyton Jones, co-creator of Haskell, about functional programming, its emphasis on values rather than mutation, and how it differs from imperative programming.

### Source excerpt

Simon Peyton Jones is the co-creator of Haskell (pure functional programming language) and I interviewed him about functional programming, why it matters, and his thoughts on other programming languages.

## Profunctor Equipment in Haskell

DevFeed: [Profunctor Equipment in Haskell](<https://devfeed.tech/articles/profunctor-equipment-in-haskell-28856.md>)

Original publisher: [Read original article](<https://bartoszmilewski.com/2026/05/16/profunctor-equipment-in-haskell/>)

Author: Bartosz Milewski

Published: 2026-05-16T09:47:40Z

Content type: tutorial

Language: en

Sources: [Bartosz Milewski's Programming Cafe](<https://devfeed.tech/sources/bartosz-milewski-s-programming-cafe.md>)

Topics: [Haskell](<https://devfeed.tech/topics/haskell.md>), [implementation](<https://devfeed.tech/topics/implementation.md>), [Code](<https://devfeed.tech/topics/code.md>), [Library](<https://devfeed.tech/topics/library.md>), [trust](<https://devfeed.tech/topics/trust.md>)

Tags: [category-theory](<https://devfeed.tech/tags/category-theory.md>), [code](<https://devfeed.tech/tags/code.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [haskell](<https://devfeed.tech/tags/haskell.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [library](<https://devfeed.tech/tags/library.md>), [profunctor-equipment](<https://devfeed.tech/tags/profunctor-equipment.md>), [profunctors](<https://devfeed.tech/tags/profunctors.md>), [programming](<https://devfeed.tech/tags/programming.md>), [standard-library](<https://devfeed.tech/tags/standard-library.md>), [types](<https://devfeed.tech/tags/types.md>)

### AI overview

This article presents a toy Haskell implementation of profunctor equipment. It explains how cells, composition, units, companions, and conjoints can be represented using standard library types, natural transformations, existential types, and profunctor composition, while noting limitations that would require dependent types.

### Source excerpt

Previously: Profunctor Equipment. To make things more palatable for programmers, I decided to provide a toy implementation of some of the equipments in Haskell. The advantage of this encoding is that it can be verified by the compiler, and I still trust the compiler more than I trust the AI. A more adequate implementation would [...]

## Using Ledger, plain text accounting and a touch of AI to fill in my UK tax return

DevFeed: [Using Ledger, plain text accounting and a touch of AI to fill in my UK tax return](<https://devfeed.tech/articles/using-ledger-plain-text-accounting-and-a-touch-of-ai-to-fill-in-my-uk-tax-return-53064.md>)

Original publisher: [Read original article](<https://www.jvt.me/posts/2026/02/01/ledger/>)

Author: Jamie Tanna

Published: 2026-02-01T20:27:49Z

Content type: article

Language: en

Sources: [Jamie Tanna](<https://devfeed.tech/sources/articles-on-jamie-tanna-software-engineer.md>)

Topics: [Developer Tools](<https://devfeed.tech/topics/developer-tools.md>), [software-development](<https://devfeed.tech/topics/software-development.md>), [Haskell](<https://devfeed.tech/topics/haskell.md>), [Python](<https://devfeed.tech/topics/python.md>), [Ruby](<https://devfeed.tech/topics/ruby.md>), [SQLite](<https://devfeed.tech/topics/sqlite.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Parsing](<https://devfeed.tech/topics/parsing.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [blogumentation](<https://devfeed.tech/tags/blogumentation.md>), [code](<https://devfeed.tech/tags/code.md>), [data](<https://devfeed.tech/tags/data.md>), [development](<https://devfeed.tech/tags/development.md>), [finance](<https://devfeed.tech/tags/finance.md>), [haskell](<https://devfeed.tech/tags/haskell.md>), [llm](<https://devfeed.tech/tags/llm.md>), [parsing](<https://devfeed.tech/tags/parsing.md>), [python](<https://devfeed.tech/tags/python.md>), [ruby](<https://devfeed.tech/tags/ruby.md>), [sqlite](<https://devfeed.tech/tags/sqlite.md>), [tooling](<https://devfeed.tech/tags/tooling.md>)

### AI overview

A personal account of using Ledger and plain-text accounting to manage a UK self-assessment tax return. It discusses avoiding vendor lock-in, storing financial data in source control, comparing Python and Ruby tooling, and using existing ledger formats and LLM-compatible interfaces for imports and queries.

### Source excerpt

A few weeks ago, I was reading Siddhant Goel's post about 10 years using plain text accounting, and I found it a really interesting read, but decided that this level of tracking was unfortunately not for me (and my ADHD brain. It wasn't until a few weeks later, where I was filling in my first UK self-assessment tax return, that I wondered if maybe this is something I should be doing, at least to manage the process more easily. (I want to clarify that I was very sensible and did not start investing in the tooling until I'd done my first draft of the return, so I didn't spend precious time trying to perfect an unnecessary system!) Although I could use Beancount as Siddhant did, I didn't particularly fancy having to use a Python-based tool, especially if I was going to need to write + maintain code to manage parsing/importing different file formats. (I don't have a super strong dislike of Python, but after many years using it as my primary language, I found Ruby and fell in love with it instead, and I find it always a little jarring coming back to Python) Although I could vibe-code integrations or importers, not really needing to touch the Python code, I didn't want to if I could avoid it. I searched around, and found that there were a few alternatives, the most promising being Ledger. Why plain text accounting? The Plain Text Accounting model of tracking financial data in plain text is something I very much agree with. Especially where you want to avoid lock-in to a vendor, and have some control over the raw data yourself, storing that in a set of plain text file(s) is a great idea, and allows you to i.e. store them in source control and get handy diffs. Ledger When I found ledger, I also noticed there was a Haskell version, hledger, which seemed to have some good active development, but neither would be codebases I'd be able to contribute to without some help. Although I was considering something like creating a lightweight SQLite database for this, it turns out I do

## Haskell Debugger for GHC 9.14

DevFeed: [Haskell Debugger for GHC 9.14](<https://devfeed.tech/articles/haskell-debugger-for-ghc-9-14-27920.md>)

Original publisher: [Read original article](<http://alt-romes.github.io/posts/2026-01-07-haskell-debugger-for-ghc914.html>)

Published: 2026-01-07T00:00:00Z

Content type: tutorial

Language: en

Sources: [Romes' Musings](<https://devfeed.tech/sources/romes-musings.md>)

Topics: [debugging](<https://devfeed.tech/topics/debugging.md>), [Haskell](<https://devfeed.tech/topics/haskell.md>), [Neovim](<https://devfeed.tech/topics/neovim.md>), [Visual Studio Code](<https://devfeed.tech/topics/visual-studio-code.md>), [Protocol (disambiguation)](<https://devfeed.tech/topics/protocol.md>), [GitHub Issues](<https://devfeed.tech/topics/github-issues.md>)

Tags: [bytecode](<https://devfeed.tech/tags/bytecode.md>), [crashes](<https://devfeed.tech/tags/crashes.md>), [debugger](<https://devfeed.tech/tags/debugger.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [editor](<https://devfeed.tech/tags/editor.md>), [haskell](<https://devfeed.tech/tags/haskell.md>), [issue](<https://devfeed.tech/tags/issue.md>), [performance](<https://devfeed.tech/tags/performance.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [vscode](<https://devfeed.tech/tags/vscode.md>)

### AI overview

This article announces that the Haskell Debugger is ready for GHC 9.14 and explains how to install it and configure editors through the Debug Adapter Protocol. It covers VSCode and Neovim integration, project-based session configuration, robustness goals, current limitations, and planned callstack and multithreading support.

### Source excerpt

This post was first published inline to the Haskell Discourse, where there was some discussion about the debugger: 1 The Haskell Debugger for GHC 9.14 The Haskell Debugger is ready to use with GHC-9.14! The installation, configuration, and talks can be found in the official website. The tl;dr first step is installing the debugger: $ ghc --version # MUST BE GHC 9.14 The Glorious Glasgow Haskell Compilation System, version 9.14.1 $ cabal install haskell-debugger \ --allow-newer=base,time,containers,ghc,ghc-bignum,template-haskell \ --enable-executable-dynamic # ON WINDOWS, DO NOT PASS --enable-executable-dynamic ... $ ~/.local/bin/hdb --version # VERIFY IT'S THE LATEST! Haskell Debugger, version 0.11.0.0 The second step is configuring your editor to use the debugger via the Debug Adapter Protocol (DAP). - For VSCode, install the haskell debugger extension. - For Neovim, install nvim-dap and configure it for haskell-debugger - For other editors, consult your DAP documentation and let others know how! Bug reports and discussions are welcome in the haskell-debugger issue tracker. My MuniHac 2025 talk also walks through the installation, usage, and design of the debugger. Do note much has been improved since the talk was given, and much more will still improve. 1.1 A little bit more info The debugger work is sponsored by Mercury. It's the project in which I've spent most of my full working days (for almost a full year now), with the invaluable help from my team at Well-Typed. The debugger is meant to work both on trivial files and on large and complex codebases1. It is a GHC application so all features are supported. Like HLS, it also uses hie-bios to automatically configure the session based on your cabal or stack project. Robustness is a main goal of the debugger. If anything doesn't work, or if you have performance issues, or something crashes, please don't hesitate to submit a bug. We've got a small but respectable testsuite, and have tested performance by debugging G

## Lazy Linearity for a Core Functional Language (POPL 2026)

DevFeed: [Lazy Linearity for a Core Functional Language (POPL 2026)](<https://devfeed.tech/articles/lazy-linearity-for-a-core-functional-language-popl-2026-27919.md>)

Original publisher: [Read original article](<http://alt-romes.github.io/posts/2025-11-26-lazy-linearity-popl26.html>)

Published: 2025-11-26T00:00:00Z

Content type: release

Language: en

Sources: [Romes' Musings](<https://devfeed.tech/sources/romes-musings.md>)

Topics: [Haskell](<https://devfeed.tech/topics/haskell.md>), [Programming Language Type Systems](<https://devfeed.tech/topics/programming-language-type-systems.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>)

Tags: [2023](<https://devfeed.tech/tags/2023.md>), [2026](<https://devfeed.tech/tags/2026.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [core](<https://devfeed.tech/tags/core.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [functional](<https://devfeed.tech/tags/functional.md>), [ghc](<https://devfeed.tech/tags/ghc.md>), [haskell](<https://devfeed.tech/tags/haskell.md>), [language](<https://devfeed.tech/tags/language.md>), [languages](<https://devfeed.tech/tags/languages.md>), [lazy](<https://devfeed.tech/tags/lazy.md>), [linear](<https://devfeed.tech/tags/linear.md>), [optimisations](<https://devfeed.tech/tags/optimisations.md>), [paper](<https://devfeed.tech/tags/paper.md>), [pdf](<https://devfeed.tech/tags/pdf.md>), [program](<https://devfeed.tech/tags/program.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [research](<https://devfeed.tech/tags/research.md>)

### AI overview

The paper introduces Linear Core, a system that checks linear resource use according to lazy semantics. In Haskell's optimizing compiler, rewrites can break syntactic linearity even when a program's behavior preserves linear resource use, so traditional syntactic linear type systems can reject optimized Core programs. The authors prove Linear Core sound and show that multiple optimizing transformations preserve linearity in it while failing to do so in Core. They implemented it as a compiler plugin and tested it against linearity-heavy libraries, including linear-base. The excerpt does not detail the transformations or report evaluation results.

### Source excerpt

I'm very proud to announce that Lazy Linearity for a Core Functional Language, a paper by myself and Bernardo Toninho, will be published at POPL 26! [DOI, ACM]. The extended version of the paper, which includes all proofs, is available here [arXiv, PDF, DOI]. The short-ish story: In 2023, for my Master's thesis, I reached out to Arnaud Spiwack to discuss how Linear Types had been implemented in GHC. I wanted to research compiler optimisations made possible by linearity. Arnaud was quick to tell me: "Well yes, but you can't!" "Even though Haskell is linearly typed, Core isn't!"1 Linearity is ignored in Core because, as soon as it's optimised, previously valid linear programs become invalid. It turns out that traditional linear type systems are too syntactic, or strict, about understanding linearity - but Haskell, regardless of linear types, is lazily evaluated. Improving optimisations would have to wait. Our paper presents a system which, in contrast, also accepts programs that can only be understood as linear under non-strict evaluation. Including the vast majority of optimised linear Core programs (with proofs!). The key ideas of this paper were developed during my Master's, but it took a few more years of on-and-off work (supported by my employer Well-Typed) with Bernardo to crystalize the understanding of a "lazy linearity" and strengthen the theoretical results. Now, the proof of the pudding is in the eating. Go read it! Abstract Traditionally, in linearly typed languages, consuming a linear resource is synonymous with its syntactic occurrence in the program. However, under the lens of non-strict evaluation, linearity can be further understood semantically, where a syntactic occurrence of a resource does not necessarily entail using that resource when the program is executed. While this distinction has been largely unexplored, it turns out to be inescapable in Haskell's optimising compiler, which heavily rewrites the source program in ways that break syntactic l

## The long season of langdev

DevFeed: [The long season of langdev](<https://devfeed.tech/articles/the-long-season-of-langdev-41788.md>)

Original publisher: [Read original article](<https://blog.fogus.me/langdev/long-season/>)

Author: fogus

Published: 2025-08-19T12:44:49Z

Content type: article

Language: en

Sources: [Mike Fogus](<https://devfeed.tech/sources/mike-fogus.md>)

Topics: [Programming](<https://devfeed.tech/topics/programming.md>), [software-development](<https://devfeed.tech/topics/software-development.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Python](<https://devfeed.tech/topics/python.md>), [Haskell](<https://devfeed.tech/topics/haskell.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>)

Tags: [accessibility](<https://devfeed.tech/tags/accessibility.md>), [ai](<https://devfeed.tech/tags/ai.md>), [async](<https://devfeed.tech/tags/async.md>), [await](<https://devfeed.tech/tags/await.md>), [carbon](<https://devfeed.tech/tags/carbon.md>), [clojure](<https://devfeed.tech/tags/clojure.md>), [code](<https://devfeed.tech/tags/code.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [computing](<https://devfeed.tech/tags/computing.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [dart](<https://devfeed.tech/tags/dart.md>), [data-driven](<https://devfeed.tech/tags/data-driven.md>), [design](<https://devfeed.tech/tags/design.md>), [development](<https://devfeed.tech/tags/development.md>), [elixir](<https://devfeed.tech/tags/elixir.md>), [f-sharp](<https://devfeed.tech/tags/f-sharp.md>), [go](<https://devfeed.tech/tags/go.md>), [langdev](<https://devfeed.tech/tags/langdev.md>), [language](<https://devfeed.tech/tags/language.md>), [programming](<https://devfeed.tech/tags/programming.md>), [programming-language](<https://devfeed.tech/tags/programming-language.md>)

### AI overview

The author argues that programming language development has entered a quieter season since the 2002-2013 wave, with innovation spreading into domain-specific languages and integrated systems rather than producing many industry-shifting general-purpose languages. New languages often recombine established features, while ideas such as null safety, pattern matching, async/await, data-driven design, and higher-kinded types may take time to mature. The author also identifies higher launch expectations: a serious new language needs an integrated product and ecosystem, and faces an LLM feedback loop favoring languages with abundant training code. Mojo, Vale, Carbon, and Gleam are cited as current experiments; whether they become widely adopted remains uncertain. The text cautions that language trends are entangled with economic, cultural, and technological forces, making historical patterns hard to interpret.

### Source excerpt

Whereby I talk about programming language development and why, and where it might go...

## Automatically Packaging a Haskell Library as a Swift Binary XCFramework

DevFeed: [Automatically Packaging a Haskell Library as a Swift Binary XCFramework](<https://devfeed.tech/articles/automatically-packaging-a-haskell-library-as-a-swift-binary-xcframework-27918.md>)

Original publisher: [Read original article](<http://alt-romes.github.io/posts/2025-07-05-packaging-a-haskell-library-as-a-swift-binary-xcframework.html>)

Published: 2025-07-05T00:00:00Z

Content type: tutorial

Language: en

Sources: [Romes' Musings](<https://devfeed.tech/sources/romes-musings.md>)

Topics: [swift-package](<https://devfeed.tech/topics/swift-package.md>), [Haskell](<https://devfeed.tech/topics/haskell.md>), [Swift](<https://devfeed.tech/topics/swift.md>), [swift-package-manager](<https://devfeed.tech/topics/swift-package-manager.md>), [Library](<https://devfeed.tech/topics/library.md>), [SwiftUI](<https://devfeed.tech/topics/swiftui.md>)

Tags: [announce](<https://devfeed.tech/tags/announce.md>), [app](<https://devfeed.tech/tags/app.md>), [apple](<https://devfeed.tech/tags/apple.md>), [application](<https://devfeed.tech/tags/application.md>), [artifacts](<https://devfeed.tech/tags/artifacts.md>), [automation](<https://devfeed.tech/tags/automation.md>), [build](<https://devfeed.tech/tags/build.md>), [building](<https://devfeed.tech/tags/building.md>), [call](<https://devfeed.tech/tags/call.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [framework](<https://devfeed.tech/tags/framework.md>), [function](<https://devfeed.tech/tags/function.md>), [functions](<https://devfeed.tech/tags/functions.md>), [haskell](<https://devfeed.tech/tags/haskell.md>), [headers](<https://devfeed.tech/tags/headers.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [ide](<https://devfeed.tech/tags/ide.md>), [library](<https://devfeed.tech/tags/library.md>), [packaging](<https://devfeed.tech/tags/packaging.md>), [swift](<https://devfeed.tech/tags/swift.md>)

### AI overview

The Haskell package `xcframework` automates bundling a Cabal foreign library as an Apple XCFramework, enabling Swift projects to use Haskell exports without custom Xcode build scripts. Set the Cabal package to `build-type: Hooks`, add `xcframework` as a setup dependency, and configure `SetupHooks.hs` with the output path; `cabal build` then creates the bundle. Add it to Xcode or declare it as a binary target in a Swift package. Swift code imports the fixed `Haskell.Foreign.Exports` module, and the app must initialize the Haskell RTS with `hs_init` and shut it down with `hs_exit`. The author says the exported functions must come from a Cabal `foreign-library` stanza; linking from a normal `library` component is not resolved. Higher-level datatype marshalling remains challenging.

### Source excerpt

Contents 1 Announcing: xcframework 1.1 XCFrameworks 1.2 How to install xcframework 1.3 How to use the XCFramework in XCode 1.4 Building simple Swift package 1.5 Must use Cabal Foreign Library stanza 1.6 Conclusion I've written about Haskell x Swift interoperability before. Calling Haskell from Swift is about marshalling and the foreign function interface. But Creating a macOS app with Haskell and Swift tells the much messier tale of hijacking XCode to vodoo together the Haskell library, its headers, and two handfuls of other magic ingredients into one buildable SwiftUI application. Stop! Don't click on the last link. No, it turns out that my XCode sallies strayed very far from the yellow brick road. The IDE is confused. Recompilation bugs abound. Complexity is through the roof juggling .modulemaps, .xcconfig dynamic settings, and sketchy .sh scripts. Let's walk the happy path. 1 Announcing: xcframework Perhaps obvious in retrospect, the demon-less way to add a Haskell library to the dependencies of a Swift application is to build an independent Swift Package wrapping the Haskell library - something that can be done without XCode in sight. Easy peasy: Build the Haskell library using Cabal Create a Swift package from the Haskell artifacts Add the Swift package as a dependency to the project And it turns out that (1) and (2) can be merged together using Cabal SetupHooks! Moreover, I'm happy to announce I've neatly packaged and released that build process automation as a Haskell library called xcframework on Hackage. Onwards! - for what it does and how to use it. 1.1 XCFrameworks Apple introduced XCFramework bundles back in a WWDC19 session. An XCFramework is a multiplatform binary framework bundle. For our purposes, that means we can create a Swift Package just from a binary linkable artifact and a couple of header files. Then, any Swift project can depend on this binary Swift package and call the functions exposed to the headers and make sure the bundled library will

## Implementing Unsure Calculator in 100 lines of Haskell

DevFeed: [Implementing Unsure Calculator in 100 lines of Haskell](<https://devfeed.tech/articles/implementing-unsure-calculator-in-100-lines-of-haskell-27917.md>)

Original publisher: [Read original article](<http://alt-romes.github.io/posts/2025-04-25-unsure-calculator-in-100-lines-of-haskell.html>)

Published: 2025-04-25T00:00:00Z

Content type: tutorial

Language: en

Sources: [Romes' Musings](<https://devfeed.tech/sources/romes-musings.md>)

Topics: [Haskell](<https://devfeed.tech/topics/haskell.md>), [Error Propagation](<https://devfeed.tech/topics/error-propagation.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [software-development](<https://devfeed.tech/topics/software-development.md>), [Mathematics](<https://devfeed.tech/topics/mathematics.md>)

Tags: [arithmetic](<https://devfeed.tech/tags/arithmetic.md>), [calculator](<https://devfeed.tech/tags/calculator.md>), [distribution](<https://devfeed.tech/tags/distribution.md>), [expression](<https://devfeed.tech/tags/expression.md>), [haskell](<https://devfeed.tech/tags/haskell.md>), [implementing](<https://devfeed.tech/tags/implementing.md>), [monad](<https://devfeed.tech/tags/monad.md>), [random](<https://devfeed.tech/tags/random.md>), [range](<https://devfeed.tech/tags/range.md>), [results](<https://devfeed.tech/tags/results.md>), [uncertainty](<https://devfeed.tech/tags/uncertainty.md>)

### AI overview

The Haskell calculator represents uncertain values with a `~` range operator and samples expressions as probability distributions. A `Range` evaluates to a normal distribution whose mean is the midpoint of the bounds and whose standard deviation is one quarter of their difference, placing each bound two standard deviations from the mean. A `Dist` monad combines constants, normal draws, and continuations; `Bind` sampling splits the pseudo-random generator, while `Normal` uses the Box-Muller transform on uniform draws. An expression DSL lifts arithmetic and functions such as `sin` and `log` over distributions. The `Show` instance takes 25,000 samples, groups them into 40 nearest-value intervals, and prints a text histogram. The author reports that the result resembles the original calculator's histogram and notes that embedding the implementation in Haskell allows use of GHCi bindings and functions. The excerpt says the full program is 100 lines, but does not include all implementation details.

### Source excerpt

Contents 1 Unsure Calculator 1.1 Sampling it up 1.2 Calculator Expressions 1.3 Showing up 1.4 Conclusion 1 Unsure Calculator The recently trendy Unsure Calculator makes reasoning about numbers with some uncertainty just as easy as calculating with specific numbers. The key idea is to add a new "range" operator (written ~) to the vocabulary of a standard calculator. The range x~y denotes that a real value is uncertain, but we are 95% sure that it falls between x and y1. Reading the notation is easy: when you see 10~15, you say: "ten to fifteen". Arithmetic operations and friends (e.g. sin, or log) transparently operate on ranges and literal numbers alike. Calculation results in a plot with a range of values that the input expression can take, and with what frequency. The motivation behind the original article is neat, so I'll just recommend you read it there to learn how and why you'd use such a calculator. Here's a real life example they used: 1400~1700 * 0.55~0.65 - 600~700 - 100~200 - 30 - 20 Now, let's implement it. 1.1 Sampling it up Summon a probability monad from the void2. data Dist a where Return :: a -> Dist a Bind :: Dist b -> (b -> Dist a) -> Dist a Normal :: Double -> Double -> Dist Double instance Monad Dist where (>>=) = Bind instance Applicative Dist where pure = Return; (<*>) = ap instance Functor Dist where fmap = liftM The monad instance is free: pure = Return and (>>=) = Bind. The Normal constructor denotes a normal distribution given the standard deviation and mean. With do-notation we can easily construct a complex tree mixing Returns, Binds, and Normals. For instance: d = do s <- Normal 0 1 return (5 + s) desugars to d = Bind (Normal 0 1) (\s -> Return (5 + s)) Then, embue meaning onto a Dist a by allowing an a to be sampled according to the distribution the Dist represents. We use StdGen from random as a source of uniform pseudo-randomness: sample :: StdGen -> Dist a -> a sample g d = case d of Return x -> x Normal mean std_dev -> n1 * std_dev

## Replay '25 Day Three: Technical Deep Dives and Temporal Case Studies

DevFeed: [Replay '25 Day Three: Technical Deep Dives and Temporal Case Studies](<https://devfeed.tech/articles/replay-25-day-three-wrapping-up-in-style-35952.md>)

Original publisher: [Read original article](<https://temporal.io/blog/replay-25-day-three>)

Author: Tim Imkin

Published: 2025-03-07T00:00:00Z

Content type: article

Language: en

Sources: [Temporal](<https://devfeed.tech/sources/temporal-blog.md>)

Topics: [reliability-engineering](<https://devfeed.tech/topics/reliability-engineering.md>), [Resilience](<https://devfeed.tech/topics/resilience.md>), [Database](<https://devfeed.tech/topics/database.md>), [Automation](<https://devfeed.tech/topics/automation.md>), [Amazon Web Services](<https://devfeed.tech/topics/aws.md>), [Haskell](<https://devfeed.tech/topics/haskell.md>), [Kubernetes](<https://devfeed.tech/topics/kubernetes.md>), [Access Control](<https://devfeed.tech/topics/access-control.md>), [systems](<https://devfeed.tech/topics/systems.md>), [Software Testing](<https://devfeed.tech/topics/software-testing.md>), [control-plane](<https://devfeed.tech/topics/control-plane.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>)

Tags: [access-control](<https://devfeed.tech/tags/access-control.md>), [ai](<https://devfeed.tech/tags/ai.md>), [automation](<https://devfeed.tech/tags/automation.md>), [aws](<https://devfeed.tech/tags/aws.md>), [case-studies](<https://devfeed.tech/tags/case-studies.md>), [community](<https://devfeed.tech/tags/community.md>), [control-plane](<https://devfeed.tech/tags/control-plane.md>), [haskell](<https://devfeed.tech/tags/haskell.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [reliability](<https://devfeed.tech/tags/reliability.md>), [resilience](<https://devfeed.tech/tags/resilience.md>), [technical](<https://devfeed.tech/tags/technical.md>)

### AI overview

A recap of the final day of Replay '25, covering reliability, database automation, production patterns, enterprise adoption, and mission-critical applications built with Temporal.

### Source excerpt

The final day of Replay '25 delivered a mix of technical deep dives and real-world case studies before concluding with an unexpected twist.

## Planning Weekly Workouts in 100 lines of Haskell

DevFeed: [Planning Weekly Workouts in 100 lines of Haskell](<https://devfeed.tech/articles/planning-weekly-workouts-in-100-lines-of-haskell-27916.md>)

Original publisher: [Read original article](<http://alt-romes.github.io/posts/2024-08-14-planning-a-workout-week-with-100-lines-of-haskell.html>)

Published: 2024-08-14T00:00:00Z

Content type: tutorial

Language: en

Sources: [Romes' Musings](<https://devfeed.tech/sources/romes-musings.md>)

Topics: [Haskell](<https://devfeed.tech/topics/haskell.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Sports](<https://devfeed.tech/topics/sports.md>)

Tags: [haskell](<https://devfeed.tech/tags/haskell.md>), [logic](<https://devfeed.tech/tags/logic.md>), [planner](<https://devfeed.tech/tags/planner.md>), [planning](<https://devfeed.tech/tags/planning.md>), [program](<https://devfeed.tech/tags/program.md>), [programming](<https://devfeed.tech/tags/programming.md>), [weekly](<https://devfeed.tech/tags/weekly.md>)

### AI overview

The author models a weekly workout plan as a constraint search in Haskell using the `logict` package instead of Prolog or Clingo. `weeklySchedule` chooses a workout and run option for each weekday, then uses alternatives, `guard`, and small helper combinators to filter schedules against constraints: weekly counts for runs and strength days, placement and spacing rules, and restrictions such as no running on leg days. `observeAll` returns every valid schedule, and the standalone 100-line Cabal script prints them. The excerpt includes three resulting schedules and explains the core `logict` operations with small examples; it presents the program as a demonstration for this particular planning problem.

### Source excerpt

Contents 1 A workout planner in 100 lines of Haskell I have recently started doing some outdoors bodyweight workouts. I also want to start running again, but I'm recovering from a minor knee injury until the start of next month. Tonight I decided to put together a weekly schedule to start following next month. The first pen and paper versions were fine, but I wasn't completely satisfied. The next logical step was to write a quick program to see what possible plans I was missing. The schedule must satisfy a few constraints, but the core of it is that I should do, every week, on one axis, one short run (high-intensity) and one long run (long distance), and, on the other axis, have two pull days (as in pull-ups), two push days (as in push-ups), and two leg days (as in squats). Finding a weekly workout that satisfies certain constraints is an answer-set-programming kind of problem, best solved by some kind of logic programming. Rather than turning to Prolog or Clingo, I decided to just stick to Haskell and use the logic-programming monad from logict! 1 A workout planner in 100 lines of Haskell What follows is mostly just the demonstration of using logict applied to this particular problem. I believe the weeklySchedule function can be easily understood in general, even by anyone unfamiliar with Haskell and/or logic programming - and that's the meat of this short post and program. Note that the program is a cabal shell script which can be run by executing the script file (as in ./ScheduleExercise, as long as cabal is in path). It is standalone, and exactly 100 lines (with comments, shebangs and everything). Feel free to try and modify it! #!/usr/bin/env cabal {- cabal: build-depends: base, logict -} import Control.Applicative import Control.Monad import Control.Monad.Logic import Data.List import Data.Maybe workout = ["Push day", "Pull day", "Leg day", "No workout"] running = ["Long run", "Short run", "No run"] weekdays = ["Seg.", "Ter.", "Qua.", "Qui.", "Sex.", "Sab.", "

## Cradle: a simpler, more composable Haskell process library

DevFeed: [Cradle: a simpler, more composable Haskell process library](<https://devfeed.tech/articles/announcing-cradle-32396.md>)

Original publisher: [Read original article](<https://garnix.io/blog/announcing-cradle>)

Published: 2024-05-14T00:00:00Z

Content type: release

Language: en

Sources: [Garnix Blog](<https://devfeed.tech/sources/garnix-blog.md>)

Topics: [Haskell](<https://devfeed.tech/topics/haskell.md>), [Library](<https://devfeed.tech/topics/library.md>), [Process](<https://devfeed.tech/topics/process.md>)

Tags: [haskell](<https://devfeed.tech/tags/haskell.md>), [library](<https://devfeed.tech/tags/library.md>), [process](<https://devfeed.tech/tags/process.md>)

### AI overview

An announcement for cradle, described as a simpler and more composable Haskell process library.

### Source excerpt

A simpler, more composable Haskell process library

## Calling Haskell from Swift

DevFeed: [Calling Haskell from Swift](<https://devfeed.tech/articles/calling-haskell-from-swift-27915.md>)

Original publisher: [Read original article](<http://alt-romes.github.io/posts/2024-04-02-calling-haskell-from-swift.html>)

Published: 2024-04-02T00:00:00Z

Content type: tutorial

Language: en

Sources: [Romes' Musings](<https://devfeed.tech/sources/romes-musings.md>)

Topics: [Haskell](<https://devfeed.tech/topics/haskell.md>), [Swift](<https://devfeed.tech/topics/swift.md>), [interoperability](<https://devfeed.tech/topics/interoperability.md>), [data type](<https://devfeed.tech/topics/data-type.md>), [iOS](<https://devfeed.tech/topics/ios.md>), [macOS](<https://devfeed.tech/topics/macos.md>), [Xcode](<https://devfeed.tech/topics/xcode.md>), [SwiftUI](<https://devfeed.tech/topics/swiftui.md>)

Tags: [data-type](<https://devfeed.tech/tags/data-type.md>), [haskell](<https://devfeed.tech/tags/haskell.md>), [interoperability](<https://devfeed.tech/tags/interoperability.md>), [ios](<https://devfeed.tech/tags/ios.md>), [macos](<https://devfeed.tech/tags/macos.md>), [metaprogramming](<https://devfeed.tech/tags/metaprogramming.md>), [swift](<https://devfeed.tech/tags/swift.md>), [swiftui](<https://devfeed.tech/tags/swiftui.md>), [tutorial](<https://devfeed.tech/tags/tutorial.md>), [xcode](<https://devfeed.tech/tags/xcode.md>)

### AI overview

This tutorial explains how to call non-trivial Haskell functions from Swift in native macOS and iOS applications. It uses foreign function exports, argument and result marshaling, serialization of user-defined data types, and Swift interoperability so Haskell functions can be exposed through Swift structs, classes, and idiomatic interfaces.

### Source excerpt

Contents 1 Introduction 2 Marshaling Inputs and Outputs 2.1 Haskell's Perspective 2.2 Swift's Perspective 3 Metaprogramming at the boundaries 3.1 Haskell's perspective 3.2 Swift's perspective 4 Remarks This is the second installment of the in-depth series of blog-posts on developing native macOS and iOS applications using both Haskell and Swift/SwiftUI. This post covers how to call (non-trivial) Haskell functions from Swift by using a foreign function calling-convention strategy similar to that described by Calling Purgatory from Heaven: Binding to Rust in Haskell that requires argument and result marshaling. You may find the other blog posts in this series interesting: Creating a macOS app with Haskell and Swift The series of blog posts is further accompanied by a github repository where each commit matches a step of this tutorial. If in doubt regarding any step, check the matching commit to make it clearer. This write-up has been cross-posted to Well-Typed's Blog. 1 Introduction We'll pick up from where the last post ended - we have set up an XCode project that includes our headers generated from Haskell modules with foreign exports and linking against the foreign library declared in the cabal file. We have already been able to call a very simple Haskell function on integers from Swift via Haskell's C foreign export feature and Swift's C interoperability. This part concerns itself with calling idiomatic Haskell functions, which typically involve user-defined datatypes as inputs and outputs, from Swift. Moreover, these functions should be made available to Swift transparently, such that Swift calls them as it does other idiomatic functions, with user defined structs and classes. For the running example, the following not-very-interesting function will suffice to showcase the method we will use to expose this function from Haskell to Swift, which easily scales to other complex data types and functions. data User = User { name :: String , age :: Int } birthday :: Use

## Computed Properties for Haskell Records

DevFeed: [Computed Properties for Haskell Records](<https://devfeed.tech/articles/computed-properties-for-haskell-records-27914.md>)

Original publisher: [Read original article](<http://alt-romes.github.io/posts/2023-11-30-computed-properties-for-haskell-records.html>)

Published: 2023-11-30T00:00:00Z

Content type: article

Language: en

Sources: [Romes' Musings](<https://devfeed.tech/sources/romes-musings.md>)

Topics: [Haskell](<https://devfeed.tech/topics/haskell.md>), [properties](<https://devfeed.tech/topics/properties.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>)

Tags: [haskell](<https://devfeed.tech/tags/haskell.md>), [properties](<https://devfeed.tech/tags/properties.md>), [property](<https://devfeed.tech/tags/property.md>), [records](<https://devfeed.tech/tags/records.md>)

### AI overview

Haskell can expose a function as a computed record-dot property by defining a `HasField` instance for a type-level field name and implementing `getField` with that function. With `OverloadedRecordDot` and `DataKinds`, this lets expressions such as `some_square.area` compute a value from the record's existing fields, while the function remains usable directly. The excerpt presents `OverloadedRecordDot` as cleaner syntax and says dot-based LSP completion may help; `NamedFieldPuns` is shown as a shorter way to bind record fields in patterns. The author frames computed properties as a possible convenience, not a technique used in a project, and notes it may be considered a Haskell anti-pattern.

### Source excerpt

Contents 1 Records in Haskell 1.1 Overloaded Record Dot 1.2 Named Field Puns 2 Computed Properties 3 Conclusion 1 Records in Haskell Haskell has so-called record types, which are also commonly known as structs, for instance, in C, Swift, and Rust. To define a square, one would write: data Point = Point { x :: Int , y :: Int } data Square = Square { topLeft :: Point , bottomRight :: Point } mySquare = Square{ topLeft = Point{x = 0, y = 0} , bottomRight = Point{x = 2, y = 2} } mySquareWidth = x (bottomRight mySquare) - x (topLeft mySquare) In Haskell record types are just syntactic sugar for ordinary product types paired with functions that get and set these fields. In essence, the above is not fundamentally different from having the following standard product types and functions: data Point = Point Int Int data Square = Square Point Point x, y :: Point -> Int x (Point px _) = px y (Point _ py) = py topLeft, bottomRight :: Square -> Point topLeft (Square tl _) = tl bottomRight (Square _ br) = br -- And setters... 1.1 Overloaded Record Dot However, by turning on the OverloadedRecordDot syntax extension, you can use more syntactic sugar to project the fields of a record instead of using the field name as a standard function: {-# LANGUAGE OverloadedRecordDot #-} mySquareWidth = mySquare.bottomRight.x - mySquare.topLeft.x which is neat! I like OverloadedRecordDot. It looks clean and feels more like using proper property of the record data type. It is also less ambiguous for an LSP to suggest the record properties of a data type by typing after the ., than it is to suggest functions to apply to the record type argument. 1.2 Named Field Puns Since I'm already writing about records, I'll mention another extension I quite enjoy: NamedFieldPuns. Traditionally, when matching on a record, you can list the field names and bind variables to the value associated with that field. Continuing the above example: area :: Square -> Int area Square{topLeft = tl, bottomRight = br} = (br.x

## garn version v0.0.18

DevFeed: [garn version v0.0.18](<https://devfeed.tech/articles/garn-version-v0-0-18-32408.md>)

Original publisher: [Read original article](<https://garnix.io/blog/garn-v0_0_18>)

Author: Nov

Published: 2023-11-30T00:00:00Z

Content type: release

Language: en

Sources: [Garnix Blog](<https://devfeed.tech/sources/garnix-blog.md>)

Topics: [changelog](<https://devfeed.tech/topics/changelog.md>), [Haskell](<https://devfeed.tech/topics/haskell.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [Git](<https://devfeed.tech/topics/git.md>)

Tags: [build-tool](<https://devfeed.tech/tags/build-tool.md>), [built-in](<https://devfeed.tech/tags/built-in.md>), [command](<https://devfeed.tech/tags/command.md>), [deno](<https://devfeed.tech/tags/deno.md>), [dependency](<https://devfeed.tech/tags/dependency.md>), [directory](<https://devfeed.tech/tags/directory.md>), [environment](<https://devfeed.tech/tags/environment.md>), [file](<https://devfeed.tech/tags/file.md>), [git](<https://devfeed.tech/tags/git.md>), [haskell](<https://devfeed.tech/tags/haskell.md>), [ide](<https://devfeed.tech/tags/ide.md>), [init](<https://devfeed.tech/tags/init.md>), [nix](<https://devfeed.tech/tags/nix.md>), [release](<https://devfeed.tech/tags/release.md>), [version](<https://devfeed.tech/tags/version.md>)

### AI overview

Garn v0.0.18 adds a built-in `garn edit` command that opens `garn.ts` in VSCodium with Deno language-server support; VSCodium is currently the only editor option. Garn also includes untracked Git files in build sandboxes, avoiding missing-file errors before they are added to Git; the announcement says this uses a patch submitted to Nix. Haskell projects can now have any number of executables, including none, and `garn init` derives them from the Cabal file. `overrideDependencies` lets projects select Hackage versions instead of package-set defaults. Other changes include support for entering top-level environments and removal of the redundant `devShell` field from `mkNpmProject` and `mkYarnProject`.

### Source excerpt

Release announcement for garn version v0.0.17 and v0.0.18. Includes better Haskell support, and less confusing file tracking.

## Creating a macOS app with Haskell and Swift

DevFeed: [Creating a macOS app with Haskell and Swift](<https://devfeed.tech/articles/creating-a-macos-app-with-haskell-and-swift-27913.md>)

Original publisher: [Read original article](<http://alt-romes.github.io/posts/2023-11-10-creating-a-macos-app-with-haskell-and-swift.html>)

Published: 2023-11-10T00:00:00Z

Content type: tutorial

Language: en

Sources: [Romes' Musings](<https://devfeed.tech/sources/romes-musings.md>)

Topics: [Haskell](<https://devfeed.tech/topics/haskell.md>), [Swift](<https://devfeed.tech/topics/swift.md>), [software-development](<https://devfeed.tech/topics/software-development.md>), [SwiftUI](<https://devfeed.tech/topics/swiftui.md>), [macOS](<https://devfeed.tech/topics/macos.md>), [Learning](<https://devfeed.tech/topics/learning.md>), [iOS](<https://devfeed.tech/topics/ios.md>)

Tags: [app](<https://devfeed.tech/tags/app.md>), [apple](<https://devfeed.tech/tags/apple.md>), [build-tool](<https://devfeed.tech/tags/build-tool.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [data](<https://devfeed.tech/tags/data.md>), [functions](<https://devfeed.tech/tags/functions.md>), [ghc](<https://devfeed.tech/tags/ghc.md>), [github](<https://devfeed.tech/tags/github.md>), [github-repository](<https://devfeed.tech/tags/github-repository.md>), [haskell](<https://devfeed.tech/tags/haskell.md>), [interoperability](<https://devfeed.tech/tags/interoperability.md>), [ios](<https://devfeed.tech/tags/ios.md>), [ios-development](<https://devfeed.tech/tags/ios-development.md>), [library](<https://devfeed.tech/tags/library.md>), [linking](<https://devfeed.tech/tags/linking.md>), [macos](<https://devfeed.tech/tags/macos.md>), [swift](<https://devfeed.tech/tags/swift.md>), [swiftui](<https://devfeed.tech/tags/swiftui.md>), [types](<https://devfeed.tech/tags/types.md>), [ui](<https://devfeed.tech/tags/ui.md>)

### AI overview

The guide's first installment builds a macOS SwiftUI app that calls a Haskell factorial function through a shared library. It exports the C-compatible function from a Cabal foreign-library stanza, generates stub headers, exposes them through a Clang module map, and configures Xcode's import and library search paths. A generated xcconfig supplies the GHC runtime header and library paths; the dylib must also be copied into the app's Frameworks folder for runtime loading. Because Swift cannot call the function safely before GHC's runtime is initialized, C wrappers around hs_init and hs_exit are exported and called at app launch and termination. The author notes that Cabal's standalone option works on macOS despite being officially supported only on Windows, so that approach is undefined behavior. The walkthrough was written using Xcode 15, Cabal 3.10, and GHC 9.8; later installments are intended to cover richer types and iOS.

### Source excerpt

Contents 1 Hello, Swift, it's Haskell! 1.1 Setting up the SwiftUI app 1.2 Setting up a Haskell foreign library 1.3 Linking the Haskell library with the executable 1.4 The RTS must be initialized 2 Remarks 2.1 Further Reading This is the first part of an in-depth guide into developing a native applications for Apple platforms (macOS, iOS, etc.) using Haskell with Swift and SwiftUI. This is the first in a series of blog posts - covering the set-up required to call Haskell functions from Swift in an XCode project using SwiftUI. In future installements of the series, I intend to at least discuss calling functions with idiomatic Haskell types with Swift ones (both with and without marshaling), SwiftUI observation, and iOS development which requires GHC to produce code for the iOS compilation target. At the time of writing I'm using XCode 15, Cabal 3.10, and GHC 9.8. There will be some features I use that are only available in these recent versions, however, the general idea of interoperability between Haskell and Swift stands on its own regardless - the now 7 year old swift-haskell-tutorial is still similarly relevant and greatly informed my approach, despite the end result being considerably different. The end goal is to create a multi-(apple)-platform application whose UI is programmed in Swift using SwiftUI while the data and logic of the application is implemented in Haskell which is called from Swift. The series of blog posts is further accompanied by a github repository where each commit matches a step of this tutorial. If in doubt regarding any step, simply checking the matching commit for absolute confidence you are understanding the practical step correctly. Visit this link to the haskell-x-swift-project-steps repository! Furthermore, I'm writing a build tool that will facilitate setting up and building a project like this without having to go through all the manual steps: haskell-swift. This write-up has been cross-posted to Well-Typed's Blog. 1 Hello, Swift, i

[Next page](<https://devfeed.tech/topics/haskell.md?cursor=WyIyMDIzLTExLTEwVDAwOjAwOjAwKzAwOjAwIiwgIjFmNDIxNDM5LWE4ZDAtNDczOC04MDgwLTAzMGEzZjJjMjg3MiJd>)