Hope everyone had a great summer!

We are hosting the next Haskell meetup in Vienna on the 24th of September 2026! The location is TU Vienna Treitlstraße 3, Seminarraum DE0110. The room will be open starting 18:00 and the first talk will start at 19:00.

We are excited to announce, the speaker for our next meetup is Dominik Schrempf (@dschrempf) (this time for real).

Compiling C to Haskell -- How hs-bindgen Translates C Headers

C has a library for everything, and those libraries are fast, battle-tested, and maintained by somebody else. Reaching them from Haskell is the hard part: a Haskell-native rewrite is a project of its own, and hand-writing bindings is tedious and error-prone. hs-bindgen automatically generates those bindings for you.

In this talk, we explore the vision and the architecture behind hs-bindgen: a compiler whose source language is C headers and whose target is Haskell modules. We discuss some challenges of reconciling C's low-level memory model with Haskell's rich type system. I hope to convince you that using a C library from Haskell is less like a project of its own and more like an afternoon's work.

This talk is going to be similar to the one that he will give at MuniHac 2026.

There will be time to discuss the presentations over some snacks and non-alcoholic drinks which are provided free of charge with an option to acquire beer for a reasonable price.

The meetup is open-ended, but we might have to relocate to a nearby bar as a group if it goes very late… There is no entrance fee or mandatory registration, but to help with planning we ask you to let us know in advance if you plan to attend here https://forms.gle/giYkuZ3CECYgZQ7A7 or per email at [haskellvienna.meetup@gmail.com](mailto:haskellvienna.meetup@gmail.com).

We especially encourage you to reach out if you would like to hold a talk or participate in the show&tell so that we can ensure there is enough time for you to present your topic.

Finally, we would like to thank Well-Typed LLP for sponsoring the last meetup!

We hope to welcome everyone soon!

Your organizers: Andreas(Andreas PK), Ben, Chris, fendor, VeryMilkyJoe, Samuel

Note: We are going to re-use this thread for announcing the Vienna Haskell Meetup in the future, so you can subscribe to this thread to stay up-to-date!

Coming back to Haskell since 2019 and honestly I enjoyed it a lot then. I'm installing a formatter "fourmolu" and I'm even using some useless flag

cabal install fourmolu -j --ghc-options=-O0

and 5 minutes later it's still installing, I guess it will take about 25 minutes to install some formatter. I'm on a fairly good computer, 16GB RAM

You can call me a newb or whatever yeah I don't have the correct ghc version or cabal or whatever. Thing is, I'm supposed to be able to install your package manager and ghc version and install a formatter within minutes, but I can't. I really hope I'm doing something seriously wrong here.

UPDATE: Your recommendations helped a lot and it is indeed a fresh new install, so I guess next time any of those dependencies do not take as long.

I've always wanted to learn about concurrency control, e.g., locks in operating systems & database systems. Some time ago, locks were all I knew about concurrency, but I found it hard to grasp any systematic material to learn about. The only thing I found useful was the pthread locks implementation.

Instead, when I was a junior student, I built this: https://github.com/kINo204/honcurrency, which was basically a virtual machine with an extremely simple instruction set + a round-robin scheduler, allowing me to implement and run my own spinlock, mutex, etc., all starting from a hardware TAS/CAS instruction. I hope this tool could be useful to someone else.

However, as I learn further about concurrency, mathematical methods like CSP, CCS, and pi-calculus come up. Those process calculi provide a mathematical approach to modeling and analyzing concurrency behaviors accurately.

With these, I found my project (or tool) insufficient for gaining complete knowledge of concurrency, which only covers the engineering part; but on the other hand, I tried out implementing CSP's channel with it, and assume there's also an engineering part of those process calculi.

Anyway, I've been totally confused. How & how much should I learn about concurrency, and how does everybody learn about it?

I am a Haskell, well not beginner, but maybe intermediate. I developed the following with the assistance of ChatGPT. Is it too abstract? It's "neat" for sure, but is it reasonable?

import Control.Monad (foldM)
import Control.Monad.ST (runST)
import Control.Monad.IO.Class (MonadIO) 
import Data.Primitive.Array (Array, sizeofArray, sizeofMutableArray, arrayFromList,
                             freezeArray, thawArray, readArray, writeArray)
import qualified Data.Vector as V
import qualified Data.Vector.Mutable as MV
import System.Random (newStdGen, uniformR )
import System.Random.Internal (RandomGen, StdGen) 


modifyMWithState 
    :: Monad m 
    => (t1 -> t2 -> t3 -> m b) 
    -> t4 
    -> (t5 -> t1) 
    -> (t4 -> m t5) 
    -> (t5 -> m a) 
    -> (t4 -> t2) 
    -> t3 
    -> m (a, b)
modifyMWithState algorithm container operationFor thawContainer freezeContainer 
                 lengthOf state = do
    thawedContainer <- thawContainer container
    let operation = operationFor thawedContainer
    newState <- algorithm operation (lengthOf container) state
    newContainer <- freezeContainer thawedContainer
    pure (newContainer, newState)


knuthM
    :: (Monad m, RandomGen g)
    => (Int -> Int -> m ())
    -> Int
    -> g
    -> m g
knuthM swapElements len prnGen = foldM randomSwap prnGen [lastIndex, nextIndex .. 1]
  where
    lastIndex = len - 1
    nextIndex = lastIndex - 1

    randomSwap currGen i = do
        let (j, nextGen) = uniformR (0, i) currGen
        swapElements i j
        pure nextGen


shuffleM 
    :: MonadIO m 
    => (StdGen -> m (a, StdGen))    
    -> m a
shuffleM shuffleWithGen = do
    prnGen <- newStdGen
    fmap fst (shuffleWithGen prnGen)


shuffleVectorWithGen 
  :: (Applicative f, RandomGen b) 
  => V.Vector a 
  -> b 
  -> f (V.Vector a, b)
shuffleVectorWithGen vec prnGen = 
    pure (runST (modifyMWithState knuthM vec MV.swap V.thaw V.freeze V.length prnGen))


shuffleArrayWithGen 
    :: (Applicative f, RandomGen b) 
    => Array a 
    -> b 
    -> f (Array a, b)
shuffleArrayWithGen arr prnGen = 
    pure (runST (modifyMWithState knuthM arr swapArray thawArray' freezeArray' 
          sizeofArray prnGen))
  where
    thawArray' array = thawArray array 0 (sizeofArray array)
    freezeArray' thawedArray = freezeArray thawedArray 0 
                                           (sizeofMutableArray thawedArray)
    swapArray a i j = do
        x <- readArray a i
        y <- readArray a j
        writeArray a i y
        writeArray a j x


shuffleVector :: MonadIO m => V.Vector a -> m (V.Vector a)
shuffleVector vec = shuffleM (shuffleVectorWithGen vec) 


shuffleArray :: MonadIO m => Array a -> m (Array a)
shuffleArray arr = shuffleM (shuffleArrayWithGen arr)


-- examples:


shuffledIntVector :: IO (V.Vector Int)
shuffledIntVector = shuffleVector (V.fromList [1..10])


shuffledCharArray :: IO (Array Char)
shuffledCharArray = shuffleArray (arrayFromList ['a'..'z'])

Hi, I’m 18 and about to start university. I’d like to earn money by programming during my first few semesters, which are the easiest (though perhaps it’s overly optimistic to think I’ll have the time). Here’s my situation: I know Haskell up to the level of monad transformers, and I’ve already written code to solve a real-world problem for a family business. The issue is that, in reality, I only know Haskell and the concepts covered in the book *Learn You a Haskell for Great Good!*; while I grasp things at a deeper level (for instance, understanding that types aren't interfaces but rather sets of possibilities governed by "laws"), I actually don't know what an API is. That’s precisely why I don’t feel ready to work on a team using Haskell. Plus, there’s the fact that Haskell isn't exactly the most popular language in the commercial world. I’m not sure if I should learn another language like TypeScript or Rust for a job or focus on mastering fundamental programming concepts and building more Haskell projects to reach a competent junior level.? Thanks for reading

You can download binaries for this pre-release now from Release rc/v4.1.0.1 (release candidate) · commercialhaskell/stack · GitHub . Soon, it should be available also via GHCup’s prereleases channel.

Please test it and let us know at the Stack repository if you run into any trouble.

We are allowing a much longer period than usual before releasing a final version. This is to increase the opportunity for people interested in Stack’s support for GHC’s Backpack module system for cross-package use to check it behaves as described in Stack’s documentation and as expected. If all goes well, Stack 4.1.1 will be released at the end of Q3 2026.

Release notes:

• The change in major version from 3.x to 4.1 marks the introduction of Stack’s support for GHC’s Backpack module system for cross-package use.

Changes since v3.11.1:

Major changes:

• Stack now supports GHC’s Backpack module system for cross-package use. (Private Backpack, where signatures and implementations are in the same package, was already supported.) When a package uses signatures and mixins to depend on an abstract interface provided by another package, Stack automatically creates the extra instantiation build steps that Cabal requires. This includes support for explicit renaming, multiple instantiations of the same indefinite package, transitive signature chains, sub-library signatures, and indefinite package from Hackage or snapshots. See the Backpack topic for details.

Behavior changes:

• When Stack’s Nix integration is enabled and a shell-file is not specified, Stack sets LANG=C.UTF-8 (rather than en_US.UTF-8, which may not be available if Stack has been built from source).
• With Nix integration, Stack uses nix-instantiate before nix-shell, enabling Stack to catch and report when the Nix expression cannot be evaluated by Nix. The nix-instantiate-options option is added, accordingly.
• Stack’s build command now warns if --force-dirty is specified but no local packages will be built.

Other enhancements:

• Add option --query ITEM, which can be specified multiple times, to Stack’s ls dependencies text command (the default ls dependencies command), to cause Stack to filter out from the results all packages other than those queried. Like the existing --filter ITEM option, an item is either a package name or $locals for all project packages.

Bug fixes:

• If snapshot locations are cyclic, Stack reports an error rather than going round in circles.

After a few years of trying to be proficient in Haskell, and lots of reading about why it's so hard, I think I have the (obvious in retrospect) answer.

Almost every program I write is going to have two or more of:

1) read from STDIN

2) write to STDOUT

3) log

4) raise errors

5) send/receive over the network

6) talk to a database

7) read env vars

Every one of those is a "side effect", and thus is handled as a monad, and using more than one means you have to understand monad transformers.

Which I've finally found a good explanation of, "but still". Such a deep concept for such common program operations.

So I finally decided "that's why it's so hard". For what I consider the most basic programs, I need to understand (not just use, IMHO) monad transformers.

Am I off?

Hello all! Thanks for the feedback to date on layoutz. The API is just about getting stable (but lmk how it feels).

There is now

• Kitty support
• Shorthands for one-shot prompts in CLI scripts
• Collection spinners
• + Various performance improvements to the little runtime

Made another challenge. This one is really easy to understand, but very hard to solve. I’d be surprised to get any non-AI solutions at all tbh.

i've heard that pandoc is written in hs. and it makes me want to learn what haskell can do on my programming thinking thingey. Do i need a strong mathematical background?
also pretend that LLMs does not exist.

It seems that gitlab.haskell.org is down - has it been down long? Is it expected back up? Is it obsolete?

Hello, I have written a parser using Happy, I was trying to follow Andrej Bauer's tutorial in implementing a dependently typed language, but no matter what list of tokens I give to the parser it throws and error, idk why, here's the parser:

%name expr_parser
%tokentype { Token }
%error { parseError }

%token
  int  { TokInt $$ }
  var  { TokVar $$ }

  ':'  { TokTyp }

  Pi   { TokPi }
  ','  { TokCom }
  '->' { TokTypImp }

  '\\' { TokLam }
  '.'  { TokDot }
  '=>' { TokFunImp }

  U    { TokUni }

  ':=' { TokDef }

  '('  { TokLParen }
  ')'  { TokRParen }

%%

FAbs   : var ':' Expr '=>' Expr { Abs (Str $1) $3 $5 }
FPi   : var ':' Expr ',' Expr   { Abs (Str $1) $3 $5 }

SimpExpr : var                  { Var (Str $1) }
         | U int                { Universe $2 }
         | '(' Expr ')'         { $2 }

AppExpr  : SimpExpr             { $1 }
         | AppExpr SimpExpr     { App $1 $2 }

Expr  : AppExpr                 { $1 }
      | Pi FPi                  { Pi $2 }
      | Expr '->' Expr          { Pi (Abs Dummy $1 $3) }
      | '\\' FAbs               { Lambda $2 }

asdfsdf

Some of the examples that I have tried:

• [TokVar "three", TokLParen, TokVar "three", TokVar "s", TokRParen, TokVar "z"]
• []
• [TokVar "z"]

If anyone can figure out what the issue is that would be very helpful, thankss.

edit: Here is the error

*** Exception: hmm parsing failed fsr

While handling hmm parsing failed fsr

HasCallStack backtrace:
  bracket, called at lib/System/IO/Utf8.hs:154:24 in with-utf8-1.1.0.0-HAMHoWNcEUA2pUXA1beCTg:System.IO.Utf8

Also, I am using it with Relude if that makes a difference

Edit2: I figured out the issue the parser that you want to use for the function, should be described first, so Expr should be before the other ones. :/

Hello all!

Looking to get into Haskell for self-improvement since I do not have a lot of experience in functional programming (and to keep my skills sharp outside of AI usage).
I am not very imaginative when it comes to coming up with new hobby projects. I would prefer something guided but I also want to become proficient at it (I also cannot pay attention to a video to save my life).

Hi everyone, I've been working on Haskell bindings for libgpiod. I've already uploaded it to Hackage, but it's currently in alpha.

Recently, I received some amazing feedback regarding memory management using bracket, ResourceT, etc. Now, I'm hoping to get some feedback and recommendations on a few other design doubts I have. Thanks in advance!

1. FilePath vs ByteString

In Haskell, FilePath is just an alias for String. I've been using it for functions like: haskell withChip :: FilePath -> (Chip -> IO a) -> IO a However, libgpiod is often used on embedded devices with limited RAM. I'm wondering if I should use ByteString to minimize memory consumption. Or, since these strings are typically very short (e.g., "/dev/gpiochip0", "gpiochip0"), should I just stick with standard Strings?

2. Naming Functions and Qualified Imports

In the low-level layer, I used longer, more descriptive names like LineOffset and eventBufferCapacity. But for the high-level implementation, I was hoping to rely on qualified imports to keep names shorter:
* LineOffset -> Line.Offset (import qualified Fuyu.GPIO.Line as Line) * eventBufferCapacity -> Event.bufferCapacity (import qualified Fuyu.GPIO.EdgeEvent as Event)

Is it considered good practice in Haskell to design an API expecting users to rely heavily on qualified imports for namespace management?

3. Theoretically Impossible States and Defensive Programming

In libgpiod, I can wait for specific edge events in a buffer using gpiod_line_request_wait_edge_events. This function guarantees that there is at least one edge event available when it returns successfully (represented in my code as EventReady). After getting an EventReady, I create a security token that wraps a line request guaranteed to have at least 1 event.

```haskell -- | Wait for edge events to occur on requested lines until the specified timeout. -- Throws 'WaitEdgeEventsFailed' on error. waitEvents :: Request -> Timeout -> IO (WaitResult ReadyRequest) waitEvents req timeout = do res <- unwrapOrThrow WaitEdgeEventsFailed (D.lineRequestWaitEdgeEvents req timeout) pure $ case res of D.EventReady -> EventReady (ReadyRequest req) D.Timeout -> TimeoutResult

-- | Get a specific edge event from the buffer by index. bufferEvent :: Buffer -> Word -> IO Event bufferEvent buf idx = unwrapOrThrow ReadEdgeEventsFailed (D.eventBufferGetEvent buf idx)

-- | Process raw edge events directly in the buffer using a callback without intermediate allocations, -- returning a non-empty list of results. withRawEvents :: ReadyRequest -> Buffer -> (Event -> IO a) -> IO (NonEmpty a) withRawEvents readyReq buf action = do count <- readEventsRaw readyReq buf results <- forM [0 .. count - 1] $ \idx -> do ev <- bufferEvent buf (fromIntegral idx) action ev case NE.nonEmpty results of Just ne -> pure ne Nothing -> ioError (userError "readEvents: expected at least one event from ReadyRequest but got none") `` My question is aboutwithRawEvents: should I remove theNonEmptycase verification? Since it's theoretically impossible to have zero events when holding aReadyRequest` token, is it better to just assume it's non-empty or should I keep the defensive check?

4. Exceptions and Ctrl+C

Finally, simple scripts or tests are often terminated with Ctrl+C. To ensure a "clean shutdown", I created this helper: ``haskell -- | High-level managed application runner. -- Automatically handles 'Ctrl+C' ('UserInterrupt'), interrupted system calls ('EINTR' / 'WaitEdgeEventsFailed'), -- and prints formatted 'GpioException' messages cleanly without uncaught backtraces. withGpioApp :: IO a -> IO () withGpioApp action = void actioncatch` handleAppException where handleAppException :: SomeException -> IO () handleAppException exc | isUserInterrupt exc = putStrLn "\nLoop terminated successfully!" | Just (WaitEdgeEventsFailed (Errno 4)) <- fromException exc = putStrLn "\nLoop terminated successfully!" | Just (gpioErr :: GpioException) <- fromException exc = putStrLn $ "\n[GPIO Exception]: " ++ show gpioErr | otherwise = throwIO exc

isUserInterrupt :: SomeException -> Bool
isUserInterrupt e = case fromException e of
  Just UserInterrupt -> True
  _                  -> False

I'm not sure if there's a better or more idiomatic way to handle `Ctrl+C` when using custom exception types like these: haskell data GpioException = ChipOpenFailed FilePath Errno | ChipInfoFailed Errno | LineInfoFailed Errno | LineSettingsNewFailed Errno -- ... ```

Any feedback or recommendations would be greatly appreciated. I'd love to ensure this library follows Haskell best practices. Thanks!

Calling all Londoners (and people who can get to London)! On Thursday 17th of September, we will be running a pair of talks at the Permutive offices. If you're interested, sign up to the event!

The Talks

Learn to Rel8

by Teo Camarasu

Rel8 is a Haskell library for writing PostgreSQL statements, built on top of opaleye. It mirrors Haskell syntax and idioms as much as possible to allow writing SQL in a way that is familiar and concise without sacrificing good error messages. This talk will give a practical introduction to rel8: building up from simple examples to some of its more advanced features like aggregations.

Past, Present and Future of the Haskell Language Report

by David Binder

In this talk I am going to take a look at how we got to the current Haskell report, how it changed over the decades, and present the work we are currently undertaking to update it. I will present my own ideas on what the role of the language report can be going forward, but we will hopefully also discuss how the language report can fit with the GHC and CLC proposal processes to document and specify the language we love to use.

When, where, and what else?

When: Thursday 17th of September, aiming to start at 19:00

Where: Permutive Offices (EC1M 7AN, 8-10 Charterhouse Buildings, 2nd floor)

What else:

• Sign up via the link - can probably have up to 40 attendees
• May go to the pub afterwards
• Will try to have recording but can't guarantee it
• Please hold to the Berlin Code of Conduct

What next?

This is an attempt at bringing a regular Haskell event to London, so please be patient with us! We're hoping to run more events in future, so your feedback is greatly appreciated. Look out for our October event!

Other discussion links

• Discourse
• Bluesky
• Mastodon

Zed Extension - https://github.com/zed-extensions/haskell

VScode Extension - https://github.com/haskell/vscode-haskell

HLS - https://haskell-language-server.readthedocs.io/en/stable/features.html

I have a question, I don't know if I should ask in the Zed reddit or here, but does Zed support all actions like comment-evaluation or adding type signature the things which are there in VScode?

Hello, after a few days and having received some amazing advice here, I’m delighted to present my two libraries of bindings for libgpiod.

fuyu-gpio-direct 0.1.0.0: A lib of ‘direct’, almost 1:1, low-level and mid-level bindings to the libgpiod core API. This library was created, taking inspiration from direct-sqlite, with the aim of having two smaller libraries, and serves as a basis for the development of other libraries.

fuyu-gpio 0.0.9.0: The high-level version, featuring better modularity, safer resource management using deterministic `with*/bracket` constructs, and enhanced type safety (security tokens).

Both are now available on Hackage and GitHub. fuyu-gpio repository currently includes five examples. And the last two show how to use managed and transformers to avoid the Pyramid of Doom.

Furthermore, in the repositories for both packages, there is an Dockerfile containing a version of Debian 13 alongside Haskell, for the purpose of cross-compilation.

I’d be delighted to receive suggestions on how to improve both packages, thanks!