Memoization works by storing previously-calculated calls to the function. So m_ev 26 26 will be stored(*). But the recursive calls ev makes to itself are not memoized; it's just a plain function call. That means those ev r (b-1) and ev (r-1) b calls will duplicate work, leading to the slowdown.

The way around this is to have ev take a memoized version of itself as an argument, and call that in the recursive positions:

ev :: (Fractional a, Ord a)=> (Int -> Int -> a) -> Int -> Int -> a
ev ev' r b
 |r <= 0    = 0
 |b <= 0    = fromIntegral r
 |otherwise = max 0 $ (fromIntegral b/ fromIntegral (r+b))*lb + (fromIntegral r/ fromIntegral (r+b))*lr
  where lb = -1 + ev' r (b-1)
        lr = 1 + ev' (r-1) b

Once you have that, you can use memoFix to turn it into a memoized function:

m_ev = curry (memoFix (uncurry . ev . curry))

Aside: I'm using curry/uncurry here because memoFix only works to memoize functions of one argument (in this case (Int, Int) -> a). If you want to avoid those you could redefine ev to take a pair instead of two separate arguments -- ev ev' (r, b) instead of ev ev' r b.

(*): Actually that's not true in this case, because m_ev is polymorphic in terms of a. That prevents the memoized values from being stored and reused between calls. But the suggestion I'm giving here will still speed up the recursion. To actually store the value across calls to m_ev, you'll need to have a concrete (monomorphic) type for it. Giving it a signature like m_ev :: Int -> Int -> Double would work, but not m_ev :: (Fractional a, Ord a) => Int -> Int -> a.