Стоит ли использовать ООП?

r x = not $ elem (last x) "bf" || elem (head x) "cf" || filter (flip elem "cm") x=="mc"
    || any id (map (($x).isInfixOf) ["sf","fs","cf","fc"])
 
main = print.filter r.permutations $ "bcfms"

cp e a b c
    | r a b < e = m a b
    | otherwise = cp e (m a b) (snd $ min (r a c,a) (r b c,b)) c
        where r (x,y) (x',y') =  (x-x')**2 + (y-y')**2
              m (x,y) (x',y') = ((x+x')/ 2,  (y+y')/ 2)
 
main = print $ cp 1e-8 (1,2) (5,16) (0,5)

r a b < e -- надо заменить на
r a b < e**2 -- у меня же расстояние не линейное, чтобы с корнями не возиться

cp e a b c -- функция с именем cp (clozest point), принимающая 4 аргумента:
-- точность, один конец отрезка, другой конец и заданную точку
-- типы аргументов и возвращаемого значения выводятся компилятором самостоятельно из контекста
-- можно указать их явно, но лениво (как сабжевому коту :))
    | r a b < e**2 = m a b -- кейс, когда функция r (расстояние, описанная ниже)
-- от концов отрезка меньше квадрата точности
-- возвращаем функцию m (midle point) от концов отрезка (описана ниже)
    | otherwise = cp e (m a b) (snd $ min (r a c,a) (r b c,b)) c
-- кейс иначе - вызываем рекурсивно нашу функцию cp с теми же точностью и точкой вне отрезка
-- но с новыми концами отрезка - его серединой и тем концом, расстояние до которого меньше
        where r (x,y) (x',y') =  (x-x')**2 + (y-y')**2 -- квадрат расстояния между точками
-- корень не извлекаем, ибо нафиг - монотонная функция
              m (x,y) (x',y') = ((x+x')/ 2,  (y+y')/ 2) -- координата середины отрезка
 
main = print $ cp 1e-8 (1,2) (5,16) (0,5)

func (x,y) = if (r>0.3 && r<0.6) || r>0.9 then (-1) else 1 where r = sqrt $ ((norm x)**2+(norm y)**2)
norm x = (fromInteger x) / (fromInteger m)
 
f v (x,y)
    | mod x hm == 0 && mod y hm == 0 = func (x, y)
    | otherwise = if v then fr else sum (map func po)/4 where
        d x = div x hm * hm
        u x = d x + hm
        x1 = d x; x2 = x1+hm; y1 = d y; y2 = y1+hm;
        po = [(x1,y1),(x2,y1),(x1,y2),(x2,y2)]
        rx i j = (x2-x)*func (po!!i) + (x-x1)*func (po!!j)
        fr =  fromInteger ((y2-y)*(rx 0 1) + (y-y1)*(rx 2 3)) / (fromInteger $ hm*hm)
 
pss :: [[(GLdouble, GLdouble, GLdouble)]]
pss = map (\f -> [(norm x, norm y, f (x,y))| x<-[-m..m], y<-[-m..m]]) [func, f False, f True]
 
m = 150; hm = 15
--------------------------------------------------------------------------------------------------
main = do
    _ <- getArgsAndInitialize
    _ <- createWindow "Test raw function"
    displayCallback $= display (pss!!0)
    _ <- createWindow "Test flat interpolation"
    displayCallback $= display (pss!!1)
    _ <- createWindow "Test biline interpolation"
    displayCallback $= display (pss!!2)
    mainLoop
 
display ps = do
    clear [ColorBuffer]
    let minz = minimum zs; dz = maximum zs - minz; zs = map (\(_,_,z) -> z) ps; c z = (z-minz)/dz
    renderPrimitive Points $ do
        mapM_ (\(x,y,z) -> do
            color $ Color3 (c z) 0 (1-c z)
            vertex $ Vertex2 x y) $ ps
    flush