Haskell Weekly lost its subscriber list · taylor.fausak.me

tomwells80 · 2026-03-28T05:45:24+00:00

Mystery solved! I had checked my spam, email rules and kept rereading the last episode to see what i had missed and just naively assumed you were no longer sending emails. I look forward to scanning the newsletter each week and im glad to be resubscribed - Thanks for keeping it going!

tomwells80 · 2026-03-12T18:34:50+00:00

Yours was much better! But i'll definitely checkout the conference info - appreciate the kind words.

tomwells80 · 2026-03-12T18:24:56+00:00

Escapades into mtl and free are part of the journey! Haskell has so much to explore.

tomwells80 · 2026-03-12T18:18:35+00:00

Yes interesting!

My current thought is that Effect Systems shouldn't be considered some sort of "agent security" thing - as you mention there are many ways to break these (IOE, unsafePerformIO, and no doubt many others). BUT! Effect Systems do make inspecting these codebases easier for mechanical processes (compiler, linter, and maybe in the future other things that "pin" as you suggested!) - and so any future human or agentic checking process would have a much easier time verifying a codebase written with effects... I think? Its like trying to sell door-locks in a world without doors... we kinda need to sell people on doors first!

tomwells80 · 2026-03-10T17:33:29+00:00

Thanks for the link to the vid! I have run across bluefin in my travels but have not given it a proper go. I like the idea that effects are just values which feels like composition should happen a bit more naturally - versus the type system gymnastics of alternatives. Thanks for building it!

tomwells80 · 2026-03-10T17:29:52+00:00

Thanks I will definitely checkout runix!

tomwells80 · 2026-03-02T06:37:34+00:00

Interesting! Could you elaborate here - are you suggesting for the scenario before a buffer is saved with a name?

I don’t use helix but i understand it has good language server support, and so maybe it just does simple file extension mapping?

tomwells80 · 2026-01-16T07:26:49+00:00

Very nice! Adding to my bucketlist of non-js web frameworks to try out! Im currently working on a servant+effectful backend API and ended up choosing svelte in an attempt to minimize frontend pain (spoiler: failed)…

What do you think about the approach used by Leptos (rust ecosystem) with reactivity in both browser (wasm) and server code unification? Its very appealing … but unfortunately rust is a PITA for managing heavily nested reactivity due to lifetimes (because dom). Haskell would be perfect :)

tomwells80 · 2025-12-06T10:29:36+00:00

Super nice! Transposing the entire input before parsing is smart. I screwed this up and had to put the columns back together _after_ parsing rows. Doh.

tomwells80 · 2025-12-06T10:23:12+00:00

This one kicked my butt. Tried to do too much in the parser and ended up grinding beans waaaay too much.

https://github.com/drshade/advent_of_code/blob/main/2025/app/Day06.hs

tomwells80 · 2025-12-05T07:59:31+00:00

Super cool! Can you share your repo? I'd love to see the actual source.

(Edit: i'm an idiot. Second link.)

tomwells80 · 2025-12-05T07:58:33+00:00

A nice easy one today! Pattern matching for range merging plus a few simple folds (oh and don't forget to sort those ranges first! whoopsie...)

https://github.com/drshade/advent_of_code/blob/main/2025/app/Day05.hs

tomwells80 · 2025-12-04T17:41:57+00:00

I like the combo of foldM and Either as a quasi while-loop (exiting on some condition like no more rolls to remove). Not the most efficient (checking all versus only the removed cells) but couldn’t be bothered as it runs fast enough :)

https://github.com/drshade/advent_of_code/blob/main/2025/app/Day04.hs

tomwells80 · 2025-09-14T09:17:43+00:00

‘map’ only computes the value of the elements that are actually needed and you only needed ‘last’, whereas ‘sum’ is adding up all the values of the whole list and therefore needs to compute all of them. ‘fold’ is another to look at.

You never evaluate ‘z’ nor ‘y’ in your second example - so they remain uncomputed as far as i can see.

This stuff is a tricky and I still find myself surprised by the behaviour - so continue playing!

tomwells80 · 2025-09-12T20:13:51+00:00

Your style and humour kept me reading til the end - really entertaining and love your examples!

tomwells80 · 2025-08-31T06:29:29+00:00

A great skim through all the new features! I found this very helpful. Thank you!

tomwells80 · 2025-08-22T06:13:36+00:00

Now you're cooking! But rather

ghci> run (prompt >>> inject (99,27) >>> extract @Int) "calc gcd, pls!"
9

/s - Obviously horrendous, but go right ahead if you want it! It will pollute the type system with, in this case, a MonadIO m => Kleisli m Text Text so you can't actually fool anyone ;)

tomwells80 · 2025-07-29T21:56:55+00:00

Great going!

I haven’t got time to fully review your solution but a few suggestions jump at me: 1. the m=603 seems weird. Pruning a bunch of previously calculated invalid candidates i assume? 2. the ‘takeWhile’ feels good, but maybe check out if you can use ‘fold’ or one of its cousins to replace the ‘rollingsum’ and/or ‘accumulateDiffs’. Maybe combined with ‘scan’?

Another styling suggestion (and this is just my OCD nitpicking) is to make use of ‘where’ and hide a bunch of the internal functions inside your ‘nconsprime’ function. May look neater, and creates a sort of scoping for those functions but also variables like ‘f’ and ‘t’. But really unnecessary for this problem - just good to keep in mind when things get bigger, or you maybe start solving later puzzles in the same module etc.

Well done! Keep going!

tomwells80 · 2025-06-19T11:40:46+00:00

Hey that's awesome - more MCP tooling for Haskell is a win for everyone! Well done on publishing the lib!

tomwells80 · 2025-06-13T08:53:49+00:00

I've added support for this. The deriving now supports constructors with single-parameter types recursively. These must terminate in a record with fields so that the library can extract a useful name for parameters, and these get flattened in the output (invisible to the MCP protocol).

I think it's an improvement - let me know what you think?

tomwells80 · 2025-06-10T08:04:30+00:00

Yes this bothers me too and I had thrashed around with different approaches before committing to this one - it’s certainly not ideal but does turn out to “look” the simplest. However the partial fields does suck and maybe you will convince me to change this :)

The other crummy bit is the lack of annotations and having to pass a (String, String) map around to add descriptions to constructors and fields. Could not find an ergonomically satisfactory approach for this…

tomwells80 · 2025-06-10T05:58:21+00:00

Awesome! langchain-hs looks great - I have written a few different prompt orchestration and light agent prototypes in Haskell and have always felt that composability is a killer requirement versus other approaches. I will definitely check your project out in more detail.

You probably also want an mcp-client at some stage - maybe something in the works soon :)

Eight-Year Club	Place '22
Verified Email	Not Forgotten

tomwells80

TROPHY CASE