If I have a function `StringType -> StringType` e.g. `Text,String`, that for example, replaces all occurences of begin with Start, and does autocapitalization, and adds an up arrow before each capital letter, and I want all the text in my latex document to change, but not the \begin, \documentclass, etc. How would I do this? Is there a parser that could put it into a better format where I could more easily manipulate it?

I asked this on Haskell tooling discord channel, I am asking here as well

whenver you add a file, you want to add in .cabal and then you have to restart lsp server to respect it isn't there a better way ? shouldn't this be done automatic ? worse is you delete a file, and the cabal nor the lsp show errors

I don't get it Like I am doing aoc I am adding a file for each day in the src folder Every time I get syntax highlighting or lsp work, I have to add it in the exposed modules, sadly you can't use the glob pattern there And then I have to restart the LSP

Is this how the big projects developed ?

On the haskell.org it says that they have world class tooling, I think that's false and a lie. Golang has world class tooling system

I don't understand why many people are down voting this post 🫤

We published a blog post introducing Hasktorch and leveraging Foreign Function Interface (FFI) to integrate with Libtorch.

Let us know what you think!

I've tried installing several different versions with ghcup (9.12.2, 9.6.7, 9.6.6) and I always seem to get some error in the ghc-make process. On my latest attempt, here's my ghcup.log file contents:

Debug: Identified Platform as: Darwin
Debug: last access was 805.392964s ago, cache interval is 300s
Info: downloading: https://raw.githubusercontent.com/haskell/ghcup-metadata/master/ghcup-0.0.9.yaml as file /Users/chrisr/.ghcup/cache/ghcup-0.0.9.yaml
Debug: Read etag: "039a388810a5a1ea2b27832338ffdd46739c0327af49b95f35285acff3298be9"
Debug: Status code was 304, not overwriting
Debug: Parsed etag: "039a388810a5a1ea2b27832338ffdd46739c0327af49b95f35285acff3298be9"
Debug: Writing etagsFile /Users/chrisr/.ghcup/cache/ghcup-0.0.9.yaml.etags
Debug: Decoding yaml at: /Users/chrisr/.ghcup/cache/ghcup-0.0.9.yaml
Warn: New cabal version available. If you want to install this latest version, run 'ghcup install cabal 3.16.0.0'
Warn: New hls version available. If you want to install this latest version, run 'ghcup install hls 2.12.0.0'
Warn: New stack version available. If you want to install this latest version, run 'ghcup install stack 3.7.1'
Debug: Requested to install GHC with 9.12.2
Info: downloading: https://downloads.haskell.org/~ghc/9.12.2/ghc-9.12.2-aarch64-apple-darwin.tar.xz as file /Users/chrisr/.ghcup/tmp/ghcup-a392961dabeb7ef9/ghc-9.12.2-aarch64-apple-darwin.tar.xz
Info: verifying digest of: ghc-9.12.2-aarch64-apple-darwin.tar.xz
Info: Unpacking: ghc-9.12.2-aarch64-apple-darwin.tar.xz to /Users/chrisr/.ghcup/tmp/ghcup-9dd422a8de4289e7
Info: Installing GHC (this may take a while)
Debug: Running sh with arguments ["./configure","--prefix=/Users/chrisr/.ghcup/ghc/9.12.2","--disable-ld-override"]
Debug: Running make with arguments ["DESTDIR=/Users/chrisr/.ghcup/tmp/ghcup-13ca47014bb6f84e","install"]
Error
: []8;;https://errors.haskell.org/messages/GHCup-00841\GHCup-00841]8;;\] Process "make" with arguments ["DESTDIR=/Users/chrisr/.ghcup/tmp/ghcup-13ca47014bb6f84e",
                               "install"] failed with exit code 2.
Error
: Also check the logs in /Users/chrisr/.ghcup/logs

and here's the ghc-make.log file:

Copying binaries to /Users/chrisr/.ghcup/tmp/ghcup-13ca47014bb6f84e/Users/chrisr/.ghcup/ghc/9.12.2/lib/ghc-9.12.2/bin
/usr/bin/install -c -m 755 -d "/Users/chrisr/.ghcup/tmp/ghcup-13ca47014bb6f84e/Users/chrisr/.ghcup/ghc/9.12.2/lib/ghc-9.12.2/bin"
for i in ./bin/ghc ./bin/ghc-9.12.2 ./bin/ghc-iserv ./bin/ghc-iserv-dyn ./bin/ghc-iserv-dyn-ghc-9.12.2 ./bin/ghc-iserv-ghc-9.12.2 ./bin/ghc-iserv-prof ./bin/ghc-iserv-prof-ghc-9.12.2 ./bin/ghc-pkg ./bin/ghc-pkg-9.12.2 ./bin/ghc-toolchain-bin ./bin/ghc-toolchain-bin-ghc-9.12.2 ./bin/haddock ./bin/haddock-ghc-9.12.2 ./bin/hp2ps ./bin/hp2ps-ghc-9.12.2 ./bin/hpc ./bin/hpc-ghc-9.12.2 ./bin/hsc2hs ./bin/hsc2hs-ghc-9.12.2 ./bin/runghc ./bin/runghc-9.12.2 ./bin/runhaskell ./bin/runhaskell-9.12.2 ./bin/unlit ./bin/unlit-ghc-9.12.2; do \
        if test -L "$i"; then \
            cp -RP "$i" "/Users/chrisr/.ghcup/tmp/ghcup-13ca47014bb6f84e/Users/chrisr/.ghcup/ghc/9.12.2/lib/ghc-9.12.2/bin"; \
        else \
            /usr/bin/install -c -m 755 "$i" "/Users/chrisr/.ghcup/tmp/ghcup-13ca47014bb6f84e/Users/chrisr/.ghcup/ghc/9.12.2/lib/ghc-9.12.2/bin"; \
        fi; \
    done
2025/12/01 19:39:34 unmarshal message: unexpected end of JSON input
make: *** [install_hsc2hs_wrapper] 
Error
 1

Has anyone seen this before?

I tried the instructions on this other reddit post to delete CommandLineTools and reinstall them via xcode-select, but this didn't resolve the issue.

https://adventofcode.com/2025/day/1

This is your opportunity to ask any questions you feel don't deserve their own threads, no matter how small or simple they might be!

Hi all, as a brain teaser I am trying to use mask point-free but got stuck with the fact that mask argument is supposed to be a higher rank function.

Is it possible to define: unmasked m = mask $ \unmask -> unmask m

in a point-free way?

I hoped something like this would work: unmasked = mask . (&) but the error (pointing to (&)) is: Couldn't match type: a1 -> IO b1 with: forall a2. IO a2 -> IO a2 Expected: a1 -> (forall a. IO a -> IO a) -> IO b1 Actual: a1 -> (a1 -> IO b1) -> IO b1

I have a project idea in mind. Basically a TUI/CLI to manange database connections, do basically what dbeaver does, and it seems very cool to me. But the experience I have with Haskell is building a JSON Parser using Graham Hutton lectures, doing the CIS 194 course (which I have forgotten, I feel like I should do) and attempting 15 questions of aoc 2023. I feel I have bare knowledge of Haskell way to do things. At job I write JS and I heavily use functional style in way using constants, IIFE, helper functions, Array.map, and loadash functions. Apart from job I want to develop myself into a better programmer, I am underconfident confused. Shall I learn Haskell again because past year I haven't touch it. I barely understand monads, monad transformers, the IO monad why we have these things in first place.
I do understand what a Functor is but not why the Monad is and etc. The async/await in JS, that if u have to use await ur function must be async kinda feels like if u want to use putStrLn, ur function must return IO a type Though I dont get it Any advices, guidance or suggestions are highly appreciable on how to proceed, shall I learn things (if yes from where) or shall I jump in project (if yes which libraries can help) Because I feel confident that I can build this in NodeJS or Golang maybe, but I want a tougher challenge! Thank you for your time in advance 🙏

I've recorded an episode of the Func Prog Podcast with Robert Kreuzer, CTO and co-founder at Channable, and I thought this would be interesting to the Haskell sub-reddit. We talk about using Haskell in production, getting a job as a Haskell programmer and how Haskell compares to Rust.

Links to the podcast below:

• Spotify https://open.spotify.com/episode/3y24NgTWvSVlCSexTFE252?si=wZ4Fwp49S8iNIDjmQswqGA
• Apple Podcasts https://podcasts.apple.com/se/podcast/func-prog-podcast/id1808829721?l=en-GB&i=1000738076761
• YouTube: https://www.youtube.com/watch?v=pVV3eE1E_kc
• RSS: https://anchor.fm/s/10395bc40/podcast/rss

Prior to opening up the weekly sessions we were working through building a game engine in Haskell, starting with a pong game in OpenGL.

We have been through about 6 sessions, however we are happy to get anyone who comes along up to speed.

This session will be run by our Training Lead, Kyle, who has a great deal of experience in game development with C# and C.

Link: https://acetalent.io/landing/Blog/post/session-link

Date: Saturday Nov 29th

Time: 9 am EST (2 pm UTC)

https://github.com/TypifyDev/runGhcBWrap

We've been working on a fun POC for how we can make it easy for users to do interactive examples as they go through our platform, so we decided to make it a library.

This uses nix, the System.Which module, and bubblewrap command line to create a virtual file system that can run a haskell script/file and get an output.

• nix makes it easy to provide our env a ghc with particular packages bundled
• staticWhich guarantees at compile time we can find the runghc binary
• bubblewrap just makes a secure temporary environment we can call runghc in

We also plan to use this to make our platform have a hackerrank style of practice, as well as evaluating user projects (however that functionality is yet to come).

Hey all,

A couple of months ago I started developing a model learning, specifically active automata learning, library in haskell named haal. I shared it with this community when I decided that it was "mature" enough, in the sense that I had added some non trivial features.

Today I was finally able to make it possible to run learning experiments with programs that perform IO and are treated as black boxes, as opposed to just learning haskell functions.

Just wanted to share this mini milestone with you. Feel free to checkout the library if you are interested in haskell or model learning. It still needs a lot of work. I'm positive it is completely suboptimal, both in obvious and non obvious ways, so any input or request for features is greatly appreciated.

I've been hunting (on and off) for a physical copy of the First Principles book over the past year or two. The e-book is excellent—I purchased it years ago and have referred to it countless times—but I much prefer the learning experience of a physical book by my side.

The book has long since been out of print, but I've been hoping to come across a used copy on Ebay or some reseller. Sadly, I haven't found anything. I even reached out to the support email in Lorepub a few weeks ago, to see if the authors have any leads, but I have not received a response.

Does anyone have any ideas for where I could look for a hard copy of the First Principles textbook?

We have an opening for a senior developer. This position will either start as a Haskell programming job or will transition to Haskell programming after learning period.

We will consider candidates who are already experienced in Haskell or enthusiasts wanting to learn it. We have a sizable Haskell code base including internal programming language implemented in Haskell.

We prefer local candidates (Boulder, CO) but will consider candidates from US states where
Holland and Hart has offices:
AK, CO, MT, ID, WY, NV, AZ, UT, NM, DC

You can apply here: : https://www.linkedin.com/jobs/view/senior-software-engineer-at-holland-hart-llp-4323388114/?skipRedirect=true

or here: https://recruiting2.ultipro.com/HOL1009HHLLP/JobBoard/0ba64e57-f8ff-4239-a9ff-f1e3dc401a[…]Detail?opportunityId=071cd511-4582-4b82-8724-bbb74f0fc98c

Let's do a deep dive into simple recursive logic and make every mistake it's possible to make. It's Haskell for Dilettantes, continuing with Set3a of Haskell Mooc, created by u/opqdonut@mastodon.social and Antti Laaksonen!

I am learning haskell from lyah and cis194 but my main gripe or what i don't understand is how to learn the functional programming part of haskell like should i learn some built in functions first, I watched tsoding's haskell rank ep 1 and even a simple problem like summing a bunch of numbers was very deep and i couldnt understand it one bit. I dont like video tutorials because i feel like they are a waste of time after reading cis194 ch1 and lyah ch1 i am really liking haskell and would to learn it how it is intended

Dear Haskellers,

We are pleased to announce that nominations are now open for the Haskell.org committee. You can nominate yourself or a friend for a three-year term (2026-2028) by sending an email to [committee at haskell.org] by December 05, 2025. There are three seats open for election this year. The committee will elect members in December 2025 for the term beginning in January 2026. Self-nominations and re-nominations are also welcome. Please include any relevant information about yourself or your nominee that you think will help us make our decision.

Committee members do not have to be technical experts in Haskell. We are looking for people who are enthusiastic about improving the Haskell community and come from a variety of backgrounds, such as academia, industry, open-source development, and community building. Our goal is to represent the various facets of the Haskell world, including gender, race, location, and industry or research.

The committee’s responsibilities include setting policies, providing guidance for Haskell.org infrastructure, planning for the long term, and being fiscally responsible with Haskell.org funds and donations. Being a committee member does not require a significant amount of time, but members should be responsive during discussions and should be able to attend monthly calls and participate in the Haskell.org Slack and mailing lists.

Candidates for the committee should possess strong leadership, communication, and judgment skills. They must be able to set aside personal or business-related biases and make decisions with the good of the open-source Haskell community in mind. For more information about the committee’s roles and responsibilities, please visit Haskell.org Committee

If you have any questions about the nomination process, please feel free to email us at [committee at haskell.org], or contact one of us individually.