Learn You A Haskell for Great Good does one thing well I imho.
It discussed a random number generator to introduce the idea of internal state compared to output value.
When you pull a random number, the state of the generator changes, so that the next pulled value is different.
And this works really well to explain the State Monad.
(I'm still learning, and wading through terrible and good explanations)
"Data.Graph.stronglyConnCompR" from "containers" distinguishes between isolated vertices and vertices with self-loops, which is the behavior I needed 👍
https://hackage-content.haskell.org/package/containers-0.8/docs/Data-Graph.html#v:stronglyConnCompR
https://hackage-content.haskell.org/package/containers-0.8/docs/Data-Graph.html#t:SCC
![ghci> import Data.Graph
ghci> stronglyConnCompR [((),"foo",[])]
[AcyclicSCC ((),"foo",[])]
ghci> stronglyConnCompR [((),"foo",["foo"])]
[NECyclicSCC (((),"foo",["foo"]) :| [])]](https://files.mastodon.social/cache/media_attachments/files/114/445/376/543/134/526/original/88e6e21ab49cc4f7.png)
I've created a PR in #Nixkell, a simple #Nix #Haskell setup framework, to add support for easy building of statically-linked executables (https://github.com/pwm/nixkell/pull/50). I'd appreciate it if any Nixkell users gives it a try for their projects. I've been using this code for a couple of my projects, and it works fine for me, but I'd like to have more working examples.
@nobodyinperson Glad to read that you at least have a work-around.
Though I'm a little surprised that the top level directory convention is not being followed in a project that seems to have it's roots in UNIX. In the Windows world, it was common to package the contents of a directory in a .zip file, which caused all sorts out problems. Unpack a zip in the wrong place and cleaning up could be a real chore! I wonder if this is an artifact of #Haskell build conventions?
GHC 9.10.2 is now available
Energy prices as command prompt ASCII table -- Haskell version
https://photonsphere.org/post/2025-05-03-command-line-energy-prices-haskell/
Is there any org in #Bangalore that would like to lend their space for an #FPIndia meetup? Please dm
#India #FunctionalProgramming #Meetup #Haskell #PureScript #Erlang #Elixir #OCaml #Scala #Clojure
#haskell advice needed
puzzling out monads ...
---
occurrences :: (Eq a) => [a] -> State [(a,Int)] Int
occurrences [] = do
l <- get
return (length l)
occurrences (x:xs) = do
count x
occurrences XS
---
Q1a Why does `get` only get the first part of the monad, the list ?
Q1b Is this the "state", the s in `State s a` ?
Q2a Why does `return` only update the second part of the monad, the integer ?
Q2b Is this the "value", the a in `State s a` ?
How to control #superintelligence ?
IIUC, the approach here is to use provable languages like #Haskell to ensure the model does only the things you want and provably cannot do Bad Things.
How to deal with the required insanely large logic proofs? OFC, use #AI for that!
I'm missing something. What exact program do you want the machine to prove? Programs that the LLM writes? Or the LLM itself? Surely the latter is computationally intractable...?
Full Time Nix | Horizon Haskell with Daniel Firth (Podcast)
https://fulltimenix.com/episodes/horizon-haskell-with-daniel-firth
Discussions: https://discu.eu/q/https://fulltimenix.com/episodes/horizon-haskell-with-daniel-firth
If you want to learn #Haskell, and are not allergic to frontend development, start with #PureScript.
Yes, the tooling situation in Haskell is that bad, and it will actively prevent you from focusing on learning. PureScript meanwhile is basically Haskell, and fantastic and modern in every way.
You will thank me
GHC String Interpolation Survey - Final Results
https://discourse.haskell.org/t/ghc-string-interpolation-survey-final-results/11971
Discussions: https://discu.eu/q/https://discourse.haskell.org/t/ghc-string-interpolation-survey-final-results/11971
Issue 470 :: Haskell Weekly newsletter
https://hackage.haskell.org/package/ollama-holes-plugin
GHC plugin that can fill typed holes with LLM expansion
the following took me 3 days to get right - it passes the mooc testing
but is there a better "model solution" way than my combining an fmap inside a >>= operation ?
looks a bit clunky and non-idiomatic
---
countAndLog :: Show a => (a -> Bool) -> [a] -> Logger Int
countAndLog f [] = return 0
countAndLog f (x:xs)
| f x = Logger [show x] 1 >>= (\n -> fmap (+1) (countAndLog f xs))
| otherwise = countAndLog f xs
---
1/2
And FP was created even before that
(from "Programming Haskell" by Graham Huttom)
