Here is an example of the main part of a Haskell program (using the "pipes" combinators). It starts two concurrent pipelines. One reads user commands from a queue, encodes them, then writes them to an AMQP server. The other reads results from the AMQP server and runs them through a more complicated pipeline, the details of which aren't very interesting.
runEffectsConcurrently
(contents commandQueue >-> encoder >-> writeTo amqp)
(readFrom amqp >-> decoder
>-> skipEmpty
>-> logToFile
>-> forever (decodeMsg state)
>-> toChannel eventQueue)
What I like about this style has to do with how it avoids naming intermediate results. Instead of stuff like loops, anonymous callback functions, and variables, it approaches a declarative specification of the program's structure & behavior. I still had to give names to each component, but I didn't need to come up with names for the values that flow through the pipelines.Beyond that, though - the above code looks great - until you need to debug it.
Personally, I'd rather pay a 'naming tax' on things for the sake of readability / debugability over what the original author is shooting for any day.
I have to say, minimizing intermediate holding names makes debugging and writing clear code much easier. 97% of the time, I never miss the "naming tax".
Such pipelines aren't necessarily made up of I/O actions though; they can also be pure computations, which cannot perform side-effects such as logging. In that case, you can still insert debugging helpers, but you might need to be slightly creative. For example, if your pipeline generates a list of values, you could put debugging entries into that list.
Generally, though, the saving grace in such a case is that each component will be a pure transformation, which means that you can easily call it with a test input and inspect the output.
There are some step-by-step debugging tools for Haskell, but I haven't used them, and Haskell programmers mostly seem uninterested in that way of debugging. It doesn't fit very well with Haskell's evaluation model anyway. When I work with Haskell, I just debug in a different way, focusing on verifying correctness of functions and their combinations.
I created hs-scrape[0] to write web scrapers and I frequently use the ghci debugger[1] for step-by-step debugging.
0: https://github.com/codygman/hs-scrape/
1: https://downloads.haskell.org/~ghc/latest/docs/html/users_gu...
It means don't do this:
int x = k + 3;
int y = v * x;
int z = y - foo();
return z;
Instead, do this: return (k + 3) * v - foo();Also, for the record, I totally disagree with the author on this. This:
return (k + 3) * v - foo();
works great, until you need to debug it. Good luck then. (defn debug-it
[x]
(println x)
x)
(-> input-value
debug-it
function1
debug-it
function2
debug-it
function3
debug-it)
Debug-it could also take a custom message at each line if you wanted the output tagged with names/numbers.In the toy function given, it doesn't really matter, but in general, I think that people should aim to code for clarity, not ease of debugging.
I do think it's a smell if the expressions has side effects, but that's a different issue.
(~> (sha1 in)
(bytes->hex-string)
(bytes-append #".")
(displayln))
In pseudo-Python this would be: displayln(bytes-append(bytes->hex-string(sha1(in)), #"."))
http://www.greghendershott.com/2013/05/the-threading-macro.h...
To be honest, I'm not even really sure what the author's point is. Naming is hard? Naming is bad? Don't name things? Name everything? It just feels like an abstract nonsense piece.