You have encountered a Haskell cause célèbre that has sparked much discussion and gnashing of teeth. Basically, for the purposes of Foldable (the typeclass that provides length), 2-tuples are not considered a container of two elements, but a container of one element accompanied by some context. You can extract a list of elements of type … Read more
module Positive (toPositive, getPositive, Positive) where newtype Positive = Positive { unPositive :: Int } toPositive :: Int -> Maybe Positive toPositive n = if (n <= 0) then Nothing else Just (Positive n) — We can’t export unPositive, because unPositive can be used — to update the field. Trivially renaming it to getPositive — … Read more
This is because ghci disables buffering, while a program compiled with ghc has line buffering by default. You can see this by running this: import System.IO main = print =<< hGetBuffering stdout In ghci you see NoBuffering while with runghc you get LineBuffering. Since the newline character doesn’t print until after the user input, the … Read more
Yes, it’s just syntactic sugar, with @ read aloud as “as”. ps@(p:pt) gives you names for the list: ps the list’s head : p the list’s tail: pt Without the @, you’d have to choose between (1) or (2):(3). This syntax actually works for any constructor; if you have data Tree a = Tree a … Read more
Some explanations are in order! What is the id function for? What is the role of? Why should we need it here? id is the identity function, id x = x, and is used as the equivalent of zero when building up a chain of functions with function composition, (.). You can find it defined … Read more
It’s hard to understand higher-rank polymorphism unless you study System F directly, because Haskell is designed to hide the details of that from you in the interest of simplicity. But basically, the rough idea is that polymorphic types don’t really have the a -> b form that they do in Haskell; in reality, they look … Read more
How folds differ seems to be a frequent source of confusion, so here’s a more general overview: Consider folding a list of n values [x1, x2, x3, x4 … xn ] with some function f and seed z. foldl is: Left associative: f ( … (f (f (f (f z x1) x2) x3) x4) …) … Read more
Lazy IO has the problem that releasing whatever resource you have acquired is somewhat unpredictable, as it depends on how your program consumes the data — its “demand pattern”. Once your program drops the last reference to the resource, the GC will eventually run and release that resource. Lazy streams are a very convenient style … Read more
You can easily enough write a function that calls the readFile action, and passes the result to your index function. readAndIndex fileName = do text <- readFile fileName return $ index text However, the IO monad taints everything that uses it, so this function has the type: readAndIndex :: FilePath -> IO [(String, [Integer])]
Most of the time, you can rely on type inference to work out a signature for you. In your example, the following is sufficient: Prelude> let addTwo x y = x + y If you really want a definition with a type signature, or your definition spans over multiple lines, you can do this in … Read more