The question is wrong: you aren’t forced to spawn one thread per file/socket and use blocking calls, you get to spawn one thread per file/socket and use blocking calls. This is the cleanest solution (in any language); the only reason to avoid it in other languages is that it’s a bit inefficient there. GHC’s threads … Read more
You need some parenthesis: mergeX [] b res = b ++ res mergeX a [] res = a ++ res mergeX (a:as) (b:bs) res | a > b = mergeX as (b:bs) (a:res) | otherwise = mergeX (a:as) bs (b:res) The reason is because : has a lower precedence than function application, so mergeX a:as … Read more
The inability to control imports of instances is one of the trade-offs the Haskell typeclass system makes. Here’s an example in a hypothetical Haskell dialect where you can: Foo.hs: module Foo where data Foo = FooA | FooB deriving (Eq, Ord) Bar.hs: module Bar (myMap) where import Data.Map (Map) import qualified Data.Map as Map import … Read more
Clearly, >>= is not a way to represent function composition. Function composition is simply done with .. However, I don’t think any of the articles you’ve read meant this, either. What they meant was “upgrading” function composition to work directly with “monadic functions”, i.e. functions of the form a -> m b. The technical term … Read more
To begin with, let me offer short answers to each of these questions. I will then expand each into a longer detailed answer, but these short ones will hopefully help in navigating those. No, Alternative and Monoid don’t mean different things; Alternative is for types which have the structure both of Applicative and of Monoid. … Read more
I guess I can answer this from authority. Is there a reason for using the books way that is much better than using all ($) symbols? There’s no special reason. Bryan and I both prefer to reduce line noise. . is quieter than $. As a result, the book uses the f . g . … Read more
Yes, that’s para. Compare with catamorphism, or foldr: para :: (a -> [a] -> b -> b) -> b -> [a] -> b foldr :: (a -> b -> b) -> b -> [a] -> b para c n (x : xs) = c x xs (para c n xs) foldr c n (x : … Read more
In shang’s answer you can see how to represent a graph using laziness. The problem with these representations is that they are very difficult to change. The knot-tying trick is useful only if you’re going to build a graph once, and afterward it never changes. In practice, should I actually want to do something with … Read more
But since a human can prove that the sequence terminates at 4, might there be a way to get the interpreter to do it? In this simple case, yes. But there cannot exist a general algorithm to determine if an expression is true or false for all natural numbers >n for some n, because Haskell … Read more
If a constant factor(1) speedup counts as significant, then I can offer a significantly more efficient version: hamm :: [Integer] hamm = mrg1 hamm3 (map (2*) hamm) where hamm5 = iterate (5*) 1 hamm3 = mrg1 hamm5 (map (3*) hamm3) merge a@(x:xs) b@(y:ys) | x < y = x : merge xs b | otherwise … Read more