The syntax [e1, e2 .. e3] is really syntactic sugar for enumFromThenTo e1 e2 e3, which is a function in the Enum typeclass. The Haskell standard defines its semantics as follows: For the types Int and Integer, the enumeration functions have the following meaning: The sequence enumFrom e1 is the list [e1,e1 + 1,e1 + … Read more
The problem in ((((a ++ b) ++ c) ++ d) ++ e) ++ f is the nesting. The applications of (++) are left-nested, and that’s bad; right-nesting a ++ (b ++ (c ++ (d ++ (e ++f)))) would not be a problem. That is because (++) is defined as [] ++ ys = ys (x:xs) … Read more
Without plumbing the depths of metaphor, might I suggest to read a typical monad m as “strategy to produce a”, so the type m value is a first class “strategy to produce a value”. Different notions of computation or external interaction require different types of strategy, but the general notion requires some regular structure to … Read more
If we compare the types (<*>) :: Applicative a => a (s -> t) -> a s -> a t (>>=) :: Monad m => m s -> (s -> m t) -> m t we get a clue to what separates the two concepts. That (s -> m t) in the type of (>>=) … Read more
String is a type, not a typeclass, so you can (must) just use it as-is in the type signature. cutString :: Num n => n -> String -> String
This is very easy with list comprehensions. To get the cartesian product of the lists xs and ys, we just need to take the tuple (x,y) for each element x in xs and each element y in ys. This gives us the following list comprehension: cartProd xs ys = [(x,y) | x <- xs, y … Read more
A type constructor which is not a Functor: newtype T a = T (a -> Int) You can make a contravariant functor out of it, but not a (covariant) functor. Try writing fmap and you’ll fail. Note that the contravariant functor version is reversed: fmap :: Functor f => (a -> b) -> f a … Read more
Haskell uses lazy-evaluation to implement recursion, so treats anything as a promise to provide a value when needed (this is called a thunk). Thunks get reduced only as much as necessary to proceed, no more. This resembles the way you simplify an expression mathematically, so it’s helpful to think of it that way. The fact … Read more
I’ll try to give an explanation in simple terms. As others have pointed out, head normal form does not apply to Haskell, so I will not consider it here. Normal form An expression in normal form is fully evaluated, and no sub-expression could be evaluated any further (i.e. it contains no un-evaluated thunks). These expressions … Read more
I have no idea what Yesod is, but I know exactly what each of your other errors means. First, you should not try to link statically. The warning you get is exactly right: if you link statically, and use one of the routines for which you are getting the warning, then you must arrange to … Read more