anything else besides pandoc and shellcheck? #haskell

A break from programming languages

https://lexi-lambda.github.io/blog/2025/05/29/a-break-from-programming-languages/

Discussions: https://discu.eu/q/https://lexi-lambda.github.io/blog/2025/05/29/a-break-from-programming-languages/

I will be teaching the #Nix track at #zurihac2025

https://zfoh.ch/zurihac2025/

Looking forward to showing you all the best(TM) way to setup #Haskell packages with Nix Maybe we can even upstream some Haskell packages to #NixOS?

I jumped in a bit on short notice and am still collecting ideas. So let me know what you would like to learn!

Violating memory safety with Haskell's value restriction

Link: https://welltypedwit.ch/posts/value-restriction
Discussion: https://news.ycombinator.com/item?id=44062576

Learning Physics with functional programming and Haskell. ~ Esteban Marín. https://dev.to/estebanmarin/learning-physics-with-functional-programming-and-haskell-l1h #Haskell #FunctionalProgramming #Physics

#Pocket is dying so it's appropriate to talk about the minimal #ReadLater service I wrote for myself: LinkFodder.

You can save links via an API, or a form, or a Telegram bot, and you get an HTML page (shown below) and an Atom #feed. That’s it.

Supports multiple users, written in #Haskell, deployable as a single binary (or a Docker image) behind the reverse-proxy server of your choice in your #SelfHosting setup.

It doesn't even need a database to run; it simply rewrites the HTML and Atom files when you save a new link.

Silly job interview questions in Haskell

Link: https://chrispenner.ca/posts/interview
Discussion: https://news.ycombinator.com/item?id=44069289

I love the episode image,

https://well-typed.com/blog/2025/05/haskell-unfolder-episode-44-state-based-testing-with-quickcheck-lockstep/

however it is slightly overselling @kosmikus reaction.

As always a very informative episode, thank you so much guys for the great channel.

Its a bit sad that you had the one episode telling us how awesome falsify is but since then every episode with property testing has been using quickcheck.

Why is #Rakulang seemingly so underappreciated?

#Ziglang and #Haskell seem to outpace Raku's adoption curve. I say that as a fan of all three languages, I'm not casting shade. One is new and the other is niche, but they both seem to me good comparisons to Raku. Just look at the sizes of each language's subreddit to get a sense of respective community size.

If those are bad comparisons, I'm open to alternatives and polite discussion.

Some observation from going back to #golang for old code:
1. Tooling is still just stellar, even the debugger is platform-independent.
2. The language is still boring, but not without footguns.
3. Part of the problems with cool languages, such as #cl, #rust or #haskell is that people often are motivated by language, but not by result. Will not happen in golang, no one will be excited by it. Don't know if it is good or bad, but certainly feels productive.

Finished the Uni of Helsinki #haskell mooc !

#haskell question re "phantom types"

my solution to `render` works

---

class Render currency where
render :: Money currency -> String

instance Render EUR where
render (Money s)= show s ++ "e"

instance Render USD where
render (Money s)= "$" ++ show s

instance Render CHF where
render (Money s)= show s ++ "chf"

---

BUT I want something simpler like

instance Render curreny where
render (Money s):: Money EUR = ...
render (Money s):: Money USD = ...

1/2

I'm on the last chapter of the University of Finland's Haskell mooc course.

Of all the languages I've tried over 30+ years

* #haskell pushed me to think in terms of higher-order functions - and also to value the importance of types

* #prolog was the first to make think declaratively and to solve problems by riding on its internal (search) mechanism

* #6502 on the BBC micro gave me empathy for what's happening "on metal"

* #lean opened my eyes to the power of #cs theory to check maths

I wrote a new note: "Reading Time Estimates for #Pandoc Based Blog Generators" https://notes.abhinavsarkar.net/2025/pandoc-reading-time

I've just done a couple of #haskell exercises where the solution needed the following compositions

(pure . pure)

(fmap . fmap)

(liftA2 . liftA2)

Apart from the first one, my brain finds it difficult to establish an intuitive understanding of them.

I can't say "oh of course I know what it does"

My question is - do most haskell / functional programmers find this difficult or is it just me?

#haskell - not a question

just saying this is cool!

----

tryAll :: Alternative f => (a -> f b) -> [a] -> f b
tryAll g [] = empty
tryAll g (x:xs) = g x <|> tryAll g xs