The history of the language, including major milestones and design decisions, is described in A History of Haskell: being lazy with class. @INPROCEEDINGS{Hudak07ahistory, author = {Paul Hudak and John Hughes and Simon Peyton Jones and Philip Wadler}, title = {A history of Haskell: Being lazy with class}, booktitle = {In Proceedings of the 3rd ACM … Read more
You have to convert the operands to floats first and then divide, otherwise you’ll perform an integer division (no decimal places). Laconic solution (requires Data.Function) foo = (/) `on` fromIntegral which is short for foo a b = (fromIntegral a) / (fromIntegral b) with foo :: Int -> Int -> Float
It’s commonly used with parser combinators. For example, if space is a parser combinator that matches a single whitespace character, many space would be one that would match consecutive whitespace. I can agree that it’s slightly out of place in Control.Applicative, though.
This is fine; no stack overflow will occur. Stack overflows in Haskell (and, indeed, any non-strict language) are different to those in other languages; they arise from accumulating large values without ever evaluating them, but you’re not accumulating anything here; just sequencing an infinite chain of actions. You can think of it like this: Once … Read more
So the concern for “real time” is the latency introduced by GC collections. GHC uses a multicore garbage collector (and there is a branch with per-thread local heaps). Originally developed to improve multcore performance (each core can collect independently) by reducing the cost of frequent stop-the-world synchronisation, this happens to also benefit soft-real time for … Read more
We say Idris has strict evaluation, but this is for its run-time semantics. Being a fully dependently typed language, Idris has two phases where it evaluates things, compile-time and run-time. At compile-time it will only evaluate things which it knows to be total (i.e. terminating and covering all possible inputs) in order to keep type … Read more
There are several notions by which types of kind * -> * might “compose”. The more important one is you can compose them “sequentially”. newtype Compose f g x = Compose { getCompose :: f (g x) } Here you can see that Compose has kind (* -> *) -> (* -> *) -> (* … Read more
What profunctors lack compared to arrows is the ability to compose them. If we add composition, will we get an arrow? MONOIDS This is exactly the question tackled in section 6 of “Notions of Computation as Monoids,” which unpacks a result from the (rather dense) “Categorical semantics for arrows”. “Notions” is a great paper because … Read more
Data.XYMap.Lazy and Data.XYMap.Strict for XY in {“”, “Int”, “Hash”}: The *.Strict variant forces the evaluation of the mapped-to values to WHNF before they are placed in the map. The big advantage of that is more predictable space and time behaviour, since it is much harder to build up huge thunks, especially for types of the … Read more
If you know that the string is a valid integer, or you don’t mind it blowing up if that’s not the case, read will work. If you are unfamiliar with Haskell’s typeclasses, just know that you might have to tell Haskell what type you want to read it as: main :: IO () main = … Read more