Prime factorization of an integer
Your code all looks clear and readable to me. This is basically all performance-related.

It's "divisor"

since you're not dealing with negatives, you can use the more efficient rem and quot instead of the more mathematically correct mod and div.
factorInt 1 should be [(1,1)].

In your prettyFactors method you're creating a bunch of left-nested ++'s. This leads to a quadratic complexity printing method. You can use foldr1 to switch them to right-nested ++'s and get linear time, or you could look into the showS trick. (this won't really matter since by the time your printing takes a noticeable amount of time the factorization will be taking ages.)
Addendum: In most cases foldl and foldl1 are not what you want. You usually use foldr or foldr1 when you want laziness and foldl' or foldl1' when you want strictness.

Every time you use factorInt you start takeDivizor at 2, despite the fact that you might have already tried 2,3,4.. on previous iterations. The simplest way to remedy this would be to just add a parameter to each of them telling them where to start looking for factors.

You check a lot of numbers you don't have to in your takeDivizor function, you really only need to look at a list of primes, not [2..]

You could modify maxPower to make it tail-recursive.

If I were to write this, I would probably leave out the headMaybe and takeDivizor and write factorInt something like this.

primes = 2 : [ p | p &lt;- [3,5..], all (\x -&gt; rem p x /= 0) (takeWhile (\x -&gt; x^2 &lt;= p) primes ]

factorInt :: Int -&gt; [(Int,Int)]
factorInt 1 = [(1,1)]
factorInt n = f n primes where
  f n (p:ps) | n &lt; x     = []
             | otherwise = let mp = maxPower n p in (p, mp) : f (quot n (p^mp)) ps


Note that my implementation of primes is far from optimal, you can find better implementations on the haskell wiki page for primes.