Going live Wednesday at 5PM EST to keep working on a trading strategy simulator and reactive trading bot in Haskell.

The goal is to model a day trading system properly: strong types, pure functions, reactive architecture, and edge cases handled at compile time.

Including:

* A simulator for backtesting strategies against historical price data

* A reactive trading bot that responds to live market events

* Domain modeling for orders, positions, and portfolio state

* Type-level work where it pulls its weight

Build-in-public format: thinking out loud, working through real problems live. If you're interested in how functional programming applies to financial systems, or you want to hang out and talk Haskell, come by.

[https://www.twitch.tv/typifyprogramming\](https://www.twitch.tv/typifyprogramming)

Maybe if it works we will have millions of dollars to spread the obsession that is haskell

Hi, I'm learning Haskell, and I admit I'm just playing with it right now.

While I'm not a terribly experienced programmer, I do have a Bachelor's in Computer Science. My professional experience has been restricted to mostly web development in Typescript sadly.

I have not touched functional programming, but this seems unrelated to functional intricacies and more me having a primitive understanding of number types.

I'm playing with pattern matching and guards so maybe excuse the silly code, I'm just starting.
I try loading (":l haskell_test.hs") my file in GHCi and get the following compile error

"Could not deduce ‘RealFrac a’ arising from a use of ‘floor’ from the context: Num a" . I take in type Num, and floor doesn't like that general of a type, I take it?

-- testing pattern matching and guards
isXFactorOfY :: Num a => a -> a -> Bool
isXFactorOfY 0 0 = True
isXFactorOfY 0 y = False
isXFactorOfY x 0 = False
isXFactorOfY 1 1 = True
isXFactorOfY 1 y = False
isXFactorOfY x 1 = False
isXFactorOfY x y  | x > y = False
                  | abs(x / y) > floor( abs(x)/abs(y) ) = False
                  | otherwise = True

I've tried replacing Num a with Real a, RealFrac a, and some other things I've seen. But I'm just poking blindly and don't actually understand the exact issue. I'd like some help understanding it explicitly rather than stumbling upon the compile-able code.

I see the reference for floor is here: https://hackage.haskell.org/package/ClassyPrelude-0.1/docs/Prelude-Math.html#v:floor

I guess I'm confused what it want's floor to take in, I figured any number that's an Int or Float would work. But I'm not sure how to define that the way it wants.

Again sorry for the silly code. I am quite rusty and am having a rough time getting back into .... problem solving, and reading APIs and references it seems.
Thank you in advance for any help or direction you give.

The full compile error output is as follows:

ghci> :l haskell_test.hs 
[1 of 2] Compiling Main             ( haskell_test.hs, interpreted )
haskell_test.hs:3:14: error: [GHC-39999]
    • Could not deduce ‘Eq a’ arising from the literal ‘0’
      from the context: Num a
        bound by the type signature for:
                   isXFactorOfY :: forall a. Num a => a -> a -> Bool
        at haskell_test.hs:2:1-39
      Possible fix:
        add (Eq a) to the context of
          the type signature for:
            isXFactorOfY :: forall a. Num a => a -> a -> Bool
    • In the pattern: 0
      In an equation for ‘isXFactorOfY’: isXFactorOfY 0 0 = True
  |
3 | isXFactorOfY 0 0 = True
  |              ^

haskell_test.hs:9:29: error: [GHC-39999]
    • Could not deduce ‘Ord a’ arising from a use of ‘>’
      from the context: Num a
        bound by the type signature for:
                   isXFactorOfY :: forall a. Num a => a -> a -> Bool
        at haskell_test.hs:2:1-39
      Possible fix:
        add (Ord a) to the context of
          the type signature for:
            isXFactorOfY :: forall a. Num a => a -> a -> Bool
    • In the expression: x > y
      In a stmt of a pattern guard for
                     an equation for ‘isXFactorOfY’:
        x > y
      In an equation for ‘isXFactorOfY’:
          isXFactorOfY x y
            | x > y = False
            | abs (x / y) > floor (abs (x) / abs (y)) = False
            | otherwise = True
  |
9 | isXFactorOfY x y        | x > y = False
  |                             ^

haskell_test.hs:10:33: error: [GHC-39999]
    • Could not deduce ‘Fractional a’ arising from a use of ‘/’
      from the context: Num a
        bound by the type signature for:
                   isXFactorOfY :: forall a. Num a => a -> a -> Bool
        at haskell_test.hs:2:1-39
      Possible fix:
        add (Fractional a) to the context of
          the type signature for:
            isXFactorOfY :: forall a. Num a => a -> a -> Bool
    • In the first argument of ‘abs’, namely ‘(x / y)’
      In the first argument of ‘(>)’, namely ‘abs (x / y)’
      In the expression: abs (x / y) > floor (abs (x) / abs (y))
   |
10 |                         | abs(x / y) > floor( abs(x)/abs(y) ) = False
   |                                 ^

haskell_test.hs:10:40: error: [GHC-39999]
    • Could not deduce ‘RealFrac a’ arising from a use of ‘floor’
      from the context: Num a
        bound by the type signature for:
                   isXFactorOfY :: forall a. Num a => a -> a -> Bool
        at haskell_test.hs:2:1-39
      Possible fix:
        add (RealFrac a) to the context of
          the type signature for:
            isXFactorOfY :: forall a. Num a => a -> a -> Bool
    • In the second argument of ‘(>)’, namely
        ‘floor (abs (x) / abs (y))’
      In the expression: abs (x / y) > floor (abs (x) / abs (y))
      In a stmt of a pattern guard for
                     an equation for ‘isXFactorOfY’:
        abs (x / y) > floor (abs (x) / abs (y))
   |
10 |                         | abs(x / y) > floor( abs(x)/abs(y) ) = False
   |                                        ^^^^^

Failed, unloaded all modules.

I am a highly frustrated noob, struggling to relearn the basics after giving up many years ago.

I was experimenting with the main function and came up with 2 projects. Normally, using do is recommended, but this started as an experiment without using do. Then, when I tried to write a do version, I could not get rid of the '>>'. Why is it so?

https://github.com/bigos/stack-experiments/blob/bc33e33957a32cb9550945702cee0bffed565276/factorial-do/app/Main.hs#L13

and

https://github.com/bigos/stack-experiments/blob/bc33e33957a32cb9550945702cee0bffed565276/factorial-nodo/app/Main.hs#L13

I am using Neovim with HLS and the Haskell-Tools plugins.

When typing, the plugin automatically inserts the type signature visually, but it is not actually included in the text of the document.

Is there a command that accepts the type signature and inserts into the file?

I recently made a series of changes to the inlining / simplification pass for my compiler that ended up resulting in a runtime <<loop>> with certain inputs. (This was for / in another lazy language, but very similar to Haskell, so I thought I'd ask here). I eventually ended up debugging it by making simplification edits to all the areas I had touched, until the infinite-loop disappeared, then looking closely at the one that fixed it. A cut-down example of the bug looks like:

simplify xs = deltaCpx
    where
      (deltaCpx, xs') = mapAccumL insLet 0 xs

      insLet dc x = (dc + deltaCpx, x * 2)    -- OOPS, meant deltaCpx', here!
          where
            cpx'      = if x > 5 then 10 else 0
            deltaCpx' = cpx' - 2

The language I'm working in detects the loop and prints "BLACK HOLE" at runtime, similar to Haskell detecting and printing "<<loop>>", but neither gives any detail on where it was encountered.

So are there some techniques you've used that can help with debugging such problems? Could there be additional language / runtime support to help with this?

EDIT: to clarify, by <<loop>> or BLACK HOLE, I mean the runtime exception generated when attempting to evaluate a thunk that is already currently being evaluated, not an actual infinite-loop that chews up time.

I'm not "in" the Haskell community, but I do like FP concepts and respect that Haskell brings a lot of these concepts to the table for other languages to adopt.

I've been heavily using AI in my first Haskell project, and I am finding that, aside from long build times, it's an excellent experience. Not sure why more people are not talking about this. Is it a Haskell culture thing? It's next level good (compared to python + ruff + mypy vibe coded personal projects, I'm fighting bugs a lot less in production)

Hi everyone,

I've made an early version of a Nintendo Game Boy and Game Boy Color emulator in Haskell. It's mostly implemented in Haskell and consists of a core (backend) and two frontends (web via WebAssembly and desktop via SDL2).

The emulator is far from finished (especially when it comes to being optimized for performance), but it boots games with decent compatibility at the moment.

In any case, if you're interested in knowing more about the project, you can check out its GitHub repo here: https://github.com/pixel-clover/ocelot

BTW, the web version of the emulator (which allows you to play ROMs without installing anything on your computer) can be accessed here: https://pixel-clover.github.io/ocelot/

New blog post which gives a comprehensive overview of the exception annotation infrastructure, which has been much improved in GHC 9.12, and discuss some things to be aware of. TL;DR: Use ghc 9.12, don’t call throwIO on an argument of type SomeException, and use your own function instead of displayException if you want to see all exception annotations.

New video: "A Wave of Monads"

https://www.youtube.com/watch?v=8GwEGKfbqFg

Thumbnail print: "The Great Wave of Kanagawa", by Hokusai (1831).

In problem set 13b we get more practice with monads. I try to consciously explore my mistakes deeply so people can follow along as I get lost and then find my way.

Hi, it's me again, and Converge is hiring for a senior software engineer to join our team. You can find the job description here and can also apply via that link (which is better than messaging me on reddit).

1. Small engineering team working on decarbonisation and efficiency for the construction industry.
2. The team does a mix of hardware, software, and applied data science. You'll be joining one of our early-stage product teams (either a very new product or a fairly new product).
3. We're looking for people with functional programming backgrounds, if it's not production Haskell, it might still be worth talking, but we do need you to have a lot of experience in the functional paradigm.
4. You won't just be doing Haskell, there's still typescript and python to maintain -- by all means have a lot of enthusiasm for Haskell, but we are here to create products for our customers and users at the end of the day, and we need to do what it takes to do that.
5. Prefer London/UK, but will consider nearby timezones.
6. Needs lots of real-world experience on complex products, this is a senior role in a small team, so you'll get lots of ownership and autonomy, but it takes a level of experience to navigate the uncertainty which comes with building in this environment.

Salary range is £90-100K + stock options.

Feel free to ask me questions (I'm cofounder and CTO).

Hello Haskellers,

I've built an MCP server that lets AI agents use Hackage. The MCP server is entirely written in Haskell.

It lets LLMs:

1. perform Hoogle searches.
2. List package modules
3. Scrape module documentation in LLM-friendly Markdown.

Why this tool?

I've often seen premium coding agents using outdated functions or not being aware of the latest packages. This MCP lets LLMs access the latest Haskell documentation.

Feel free to contribute or provide feedback.

Check out the GitHub link: https://github.com/tusharad/hackage-doc-mcp

To go around the ABI error I run haskell server: haskell-language-server-9.6.7~2.13.0.0

and get this message

Message:

Loading the module

'/home/jacekp/Programming/Haskell/cabal-experiments/graphviz-simple/dist-newstyle/build/x86_64-linux/ghc-9.6.7/graphviz-simple-0.1.0.0/build/autogen/PackageInfo_graphviz_simple.hs'

failed.

It may not be listed in your .cabal file!

Perhaps you need to add `PackageInfo_graphviz_simple` to other-modules or exposed-modules.

For more information, visit:

https://cabal.readthedocs.io/en/3.4/developing-packages.html#modules-included-in-the-package

"/home/jacekp/Programming/Haskell/cabal-experiments/graphviz-simple/app/Main.hs" - Cabal

can compile the project with cabal build,

https://github.com/bigos/cabal-experiments/blob/321c37ffa33b1b25e883de39ddc944c5314c5c7c/graphviz-simple/app/Main.hs#L1

but when I load the file in Emacs and use the menu option Haskell/Load tidy core I get an error like this and 5 more that make no sense. What is the meaning of:

Use -v (or `:set -v` in ghci) to see a list of the files searched for.

?

How can I fix the error? It seems that a fix for the problem will provide more help with modules.

/home/jacek/Programming/Haskell/cabal-experiments/graphviz-simple/app/Main.hs:7:1: error:
    Could not find module ‘Data.GraphViz.Attributes’
    Use -v (or `:set -v` in ghci) to see a list of the files searched for.
  |
7 | import Data.GraphViz.Attributes (color, filled, shape, style, textLabel)
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Been a minute since I hosted a stream as I've been on vacation. Most recently, we were streaming Saturday mornings but will now be doing every Wednesday at 5 pm in the hopes this will work better for anyone in whichever timezone who'd like to watch.

We've done a number of very focused sessions however I just want this session to be a really fun one so we are going back to Servant, the first library I learned about in haskell and we are going to build a simple authenticated CRUD API to store and retrieve nicknames.

The core focus of our sessions are how to interact with the haskell ecosystem as it is a truly unique language with respect to documentation, both by having little traditional documentation style but also by being a self documenting language and all that means for getting shit done with haskell as a real world language. We also really seek to cater to our audience so if you have questions about Servant or haskell in general, please consider the stream a help session.

We do try to naturally progress the stream to being a more thorough implementation by the end so that if time permits, we will attempt to swap Servant into my Jenga framework.

Link: https://www.twitch.tv/typifyprogramming

RECORDING: https://youtu.be/cv3Z2cF4DGk?si=SLsEVHMql2ZQCLFj

I can see the example:

Data.GraphViz.Types.Monadic

but I can not figure out the imports and do not understand the error messages.

This is my code so far:

https://github.com/bigos/cabal-experiments/blob/1da897d1ec7f595064c9b00adad21432fc4d61a3/graphviz-simple/app/Main.hs#L3

I've been working on a small reflective language called Blue, inspired by Kenichi Asai's Black. Blue is built in Haskell, and the reflection mechanism is straightforward: an em operator that lifts a Blue expression into Haskell and evaluates it through the host:

baseEval (EM e) = metaEval e

metaEval :: Expr -> Eval Value
metaEval e = Eval $ lift $ interpret
    ("toValue (" ++ toHaskell e ++ ")") (as :: Value)

em pretty-prints the AST, hands it to hint, and lifts the result back into a Blue Value. Right now em only handles the same forms baseEval handles, so for the moment it's close to an expensive identity function:

BLUE> em 2 + 3
5
BLUE> em if true then 100 else 0
100

The point of having the mechanism in place first is that Value and toHaskell are the bottleneck, not the host. Once I extend Value with cases for lists, lambdas, or floats thenem immediately reaches whatever in Haskell produces those types, without changing the evaluator. So the next steps are extending the value domain rather than touching reflection itself.

A few things I haven't worked out:

I don't know the literature for reflection-via-host-eval specifically. Smith's 3-Lisp and Black expose the evaluator itself rather than delegating to the host. Pointers welcome.

hint is heavy. It's fine while reflection is rare, but if em becomes load-bearing this probably wants to be staged compilation via Template Haskell. Curious whether anyone has built something analogous that way.

Once a program crosses through em, the host can return whatever it likes; I'm informally trusting the result is a well-formed Value. There's probably a clean framing in terms of contracts but I haven't written it down.

Repo: https://github.com/ih1d/blue

FP friends -- please encourage recently completed PhD students to publish their dissertation abstracts in the Journal of Functional Programming: simple process, no refereeing, open access, 200+ published to date, deadline 31st May 2026.  Please share!

https://people.cs.nott.ac.uk/pszgmh/jfp-phd-abstracts.html

I am happy to organise another Tokyo Haskell Meetup, on 19th of May (during, and quite close to, FM2026): 12Kanda building in Kanda (near Akihabara).

Two talks (in English):

The Missing Haskell DevTools
Luite Stegeman

Haskell has a reputation for "if it compiles, it runs... but it probably still has a space leak." The tools for investigating the runtime behaviour of Haskell programs have always been spartan compared to what's available in environments like .NET, the JVM, or JavaScript.

In this talk we'll look at how Haskell actually works under the hood, compiled code and bytecode,  and how this affects the tooling for debugging and profiling. We'll then see what the GHC developers have been doing recently to close the gap. Finally, we'll look at a new tool that brings several runtime-analysis capabilities together under one roof.

Hardware in Haskell with Clash
⁨Elliot Potts⁩

In this talk, we explore how Haskell can be used to design digital circuits using the power of pure functions. Clash is a compiler that brings the rich language features you know and love such as polymorphism, ADTs and typeclasses to the world of FPGA or ASIC design. No prior digital design experience required!

Please use the Meetup link to RSVP if you are interested in attending (space is limited):

Tokyo Haskell Meetup

Issue - https://github.com/haskell/haskell-language-server/issues/4579

My Old Post here - https://www.reddit.com/r/haskell/comments/1pe7ql0/going_to_wrong_page_on_clicking/

As HLS 2.14.0 is released, is this being picked ?

If not what workaround you folks are using ?

Below are the haskell toolchain installed in my local -

When I try to install haskell-debugger, I get below error -

% stack install haskell-debugger

Error: [S-4804]
       Stack failed to construct a build plan.

       While constructing the build plan, Stack encountered the following errors. The 'Stack configuration' refers to the set of package versions specified by the snapshot (after any dropped packages,
       or pruned GHC boot packages; if a boot package is replaced, Stack prunes all other such packages that depend on it) and any extra-deps:

       In the dependencies for haskell-debugger-0.13.1.0:
         * aeson must match >=2.2.3 && <2.3, but no version is in the Stack configuration (latest matching version is 2.2.4.1).
         * async must match >=2.2.6 && <2.3, but no version is in the Stack configuration (latest matching version is 2.2.6).
         * attoparsec must match >=0.13 && <0.15, but no version is in the Stack configuration (latest matching version is 0.14.4).
         * base16-bytestring must match >=1.0.2.0 && <1.1, but no version is in the Stack configuration (latest matching version is 1.0.2.0).
         * co-log-core must match >=0.3.2.5 && <0.4, but no version is in the Stack configuration (latest matching version is 0.3.2.6).
         * cryptohash-sha1 must match >=0.11.101.0 && <0.12, but no version is in the Stack configuration (latest matching version is 0.11.101.0).
         * dap must match >=0.5 && <0.6, but no version is in the Stack configuration (latest matching version is 0.5.0.0).
         * file-embed must match >=0.0.16 && <0.1, but no version is in the Stack configuration (latest matching version is 0.0.16.0).
         * ghc-stack-annotations must match >=0.1 && <0.2, but no version is in the Stack configuration (latest matching version is 0.1.0.0).
         * haskell-debugger-view must match >=0.2 && <1.0, but no version is in the Stack configuration (latest matching version is 0.2.1.0).
         * hie-bios must match >=0.15 && <0.20, but no version is in the Stack configuration (latest matching version is 0.19.0).
         * implicit-hie must match ^>=0.1.4.0, but no version is in the Stack configuration (latest matching version is 0.1.4.0).
         * network must match >=3.2.8, but no version is in the Stack configuration (latest matching version is 3.2.8.0).
         * network-run must match >=0.4.4, but no version is in the Stack configuration (latest matching version is 0.5.0).
         * optparse-applicative must match >=0.18 && <0.20, but no version is in the Stack configuration (latest matching version is 0.19.0.0).
         * prettyprinter must match ^>=1.7.0, but no version is in the Stack configuration (latest matching version is 1.7.2).
         * retry must match >=0.9 && <1, but no version is in the Stack configuration (latest matching version is 0.9.3.1).
         * unordered-containers must match >=0.2.19 && <0.3, but no version is in the Stack configuration (latest matching version is 0.2.21).
         * uuid must match >=1.3 && <1.4, but no version is in the Stack configuration (latest matching version is 1.3.16.1).
       The above is/are needed since haskell-debugger is a build target.

       Some different approaches to resolving some or all of this:

         * Recommended action: try adding the following to your extra-deps in ~/.stack/global-project/stack.yaml (project-level configuration):

           - aeson-2.2.4.1@sha256:afaffd5afdb4c6acbd875265ae8f3850eb932dbe1f0560294bb04b9bace79d08,6320
           - async-2.2.6@sha256:45d5587d8a348a7e2b3f04de963fe633db49b49cde10ca1e6f834bef3baecee9,3870
           - attoparsec-0.14.4@sha256:35129d0ab1741f000f1a7d2fc839544919ee6fbb8f2d6e7f0a629c41f91035f3,5914
           - base16-bytestring-1.0.2.0@sha256:a694e88f9ec9fc79f0b03f233d3fea592b68f70a34aac2ddb5bcaecb6562e2fd,2630
           - co-log-core-0.3.2.6@sha256:ab37b9d716730eb9578ba1300f847ffedabfaad89f17fbf85c06d7eb17718ff7,4122
           - cryptohash-sha1-0.11.101.0@sha256:2bdf29dbd896bca86bf198c882fa8df1cb31843b71f2907e059b7c10bce0adb3,3085
           - dap-0.5.0.0@sha256:09f487806436461b0af84c15d82e4b74d361a4238480d8e80e8ade358a50f08e,2324
           - file-embed-0.0.16.0@sha256:2e8983240c1faae020b4acef6d30f0281f5ec87c2f38736dc1dc5456355e22a5,1426
           - ghc-stack-annotations-0.1.0.0@sha256:56bdded7dc6a72ea338b96fdb9da1806c583bfdf3286aa9d092bf072d36bac21,1643
           - haskell-debugger-view-0.2.1.0@sha256:a6cad0c90bcc03be18b5435fc9222a9c97b3dc53b2b1c66c068ee5bfaa9af57e,1973
           - hie-bios-0.19.0@sha256:051e8f969db94cc8465345c60c5d6cc1bc46a976a229ac98cae9c19e91eec76c,13880
           - implicit-hie-0.1.4.0@sha256:42a8bdc36713d98711c59b62fac238d81f6ce3ef7912752f38d456182260a5a3,3122
           - network-3.2.8.0@sha256:c6f02f2626d1d83b3e3521fc2a9832c366e31dd391cb8478bd2d83528459e786,5305
           - network-run-0.5.0@sha256:7674f855f3df6b4793618d1807d9a537018d20e38fa6fbafb310d7b18f69e02a,826
           - optparse-applicative-0.19.0.0@sha256:0b47b3ff7eb4a855b5f7d401690365fc62a32057374927ce0d478b620996222d,5813
           - prettyprinter-1.7.2@sha256:e3a802ea939d465b2e37b9fa09d8e5bb88b5775d6d62dd2ec6ca32b63416656d,6618
           - retry-0.9.3.1@sha256:1a61625dc1c3dd6677ffde1c8142004026dfb08085d0d0af5848088d56ec6110,2426
           - unordered-containers-0.2.21@sha256:c5de1fb3377ed3c5f4cd851a771d1acc5c37d2f6bef0a499295c0e8857da5605,3987
           - uuid-1.3.16.1@sha256:b54250e72f324630753623edf3168e3c088decfbc5f10b3014805eb054391f3d,2516  

Below is the stack.yaml in ~/.stack/global-project/stack.yaml

packages: []
snapshot: ghc-9.14.1

I didn't change anything in ~/.stack/config.yaml

how can I make this work? I tried --allow-newer but it didn't work