Vlad Ardelean’s Reviews > Real World Haskell > Status Update

logging stuff while debugging code was probably so annoying for the creators of Haskell, that they decided to break its purity, for the sake of productivity:
https://hackage.haskell.org/package/b...

trace :: String -> a -> a

this PRINTS the string, and returns the a, but it's not marked as `String -> a -> IO a`...so compiler doesn't force you have to have to rewrite lots of code.

Chapter 9 shows a nice example of a piece of code written at the beginner level, vs the same code written by a more advanced hasketier. Nice to know!

Interesting little function: flip

r = \x -> f x arg

is equiv. to

r = flip f arg

...same thing, less readable XD

The author's ubiquitous anecdotes about how lots of bugs are caused by side-effects and how haskell provides out-of-the-box parallelism are extremely annoying.
Feels like he's trying to convert children to his religion.
Then again book is called "real world haskell, code you can believe in", so I should have expected religious fanaticism here...of which there is plenty. Too bad he's treating the topic anecdotically.

Haskell design pattern:
When creating new types (newtype/data), DO NOT export the data constructors.

Export:
1. The type constructor
2. A function which creates data of that type (frim more basic types)
3. A function which turns our data back to something more basic (strings/lists/ints/etc)

As such, clients using our type can't start poking in its internals, and updates can't break their code. Less breakage surface

Ok, so this is a function writte in "point-free" style.
func = f1 . f2 . f3

...lots of "points" there! Doesn't look too free of points XD
JK, "point-free" meams "no reference to the data. "Point" is supposed to stand for "data point"

good tutorial for converting recursive functions to folds

http://www.cs.nott.ac.uk/~gmh/fold.pdf

In the book, the topic of zip-ing with any number of lists is mentioned. Same in LYAHFGG.

This article mentions functions with any number of params. Very very hard to figure out:

https://wiki.haskell.org/Varargs

...still not the same as zip-ing, but interesting!

There'a a compiler flag to warn against non-exhaustive patterns in function definitions! Nice! Had the problem a few times, was wondering about it.

Oh no, scratch the last comment. Algebraic data types are "haskell data types"... ok, got it!