Adventures in Looping(blog.drewolson.org)
blog.drewolson.org
Adventures in Looping
https://blog.drewolson.org/adventures-in-looping
7 comments
so.. the whole point of the article is "I miss the break keyword"?
As much a I enjoy writing FP code in some specific situations, the problem described in this article is exactly why I usually do not reach for it when I need to solve quickly practical, production-oriented problems.
In an imperative setup, this problem simply does not exist.
In an FP setup you need to do brain contortions to get a solution to a trivial problem going.
In an imperative setup, this problem simply does not exist.
In an FP setup you need to do brain contortions to get a solution to a trivial problem going.
This is the sort of technique you learn once and use a couple times, and then it’s just sort of automatic when you find yourself in this situation. Like learning a new language, the hard part is when the way you think about programming hasn’t fully made the paradigm shift.
FP’s power lies providing tools that allow you to decouple processes like “loop forever” or “transform each item of a list” from your application’s own business logic.
FP’s power lies providing tools that allow you to decouple processes like “loop forever” or “transform each item of a list” from your application’s own business logic.
Man I love Haskell, but this shows how... I'd say immature the language is when it comes to creating software for a specific use.
Business logic is already separated into other parts of the code, and now I have one concept I need to implement: "loop until exit". I would expect a mature programming language to assist me in mapping this to code as directly as possible, but this is not the case here.
The single concept has to be implemented by combining multiple new concepts: monad combination, lifting, mzero as a terminator... which would be fine if any of these concepts assisted in separating logic, but they do not. They only serve to build the concept of "loop until exit".
Business logic is already separated into other parts of the code, and now I have one concept I need to implement: "loop until exit". I would expect a mature programming language to assist me in mapping this to code as directly as possible, but this is not the case here.
The single concept has to be implemented by combining multiple new concepts: monad combination, lifting, mzero as a terminator... which would be fine if any of these concepts assisted in separating logic, but they do not. They only serve to build the concept of "loop until exit".
The author is for some reason not using the most direct loop until exit construct. See https://news.ycombinator.com/item?id=28703896
This kind of articles which explain something which looks simple, but involve a few concepts beginners don't get to use very often; is something Haskell community needs more of. Article does a great job touching different topics to sufficient depth, keep good pace, and isn't introducing something too challenging. A great tea-time reading for a Haskell/FP beginner!
The article is kind of overcomplicating things in favor of really trying preserve `forever`.
Here's an easy one with `whileM` (the one parameter version that is effectively a do-while loop, where the while condition is the expression's return value, there is a two parameter version that takes an independent boolean parameter).
Here's an easy one with `whileM` (the one parameter version that is effectively a do-while loop, where the while condition is the expression's return value, there is a two parameter version that takes an independent boolean parameter).
main :: IO ()
main = do
wsUrl <- fetchConnectionUrl
conn <- connectWebSocket wsUrl
whileM $ do
message <- readMessage conn
case message of
MessageA val -> putStrLn "Message A" $> True
MessageB val -> putStrLn "Message B" $> True
Disconnect -> pure False