Разбить список на подсписки

разделить_относительно :: Ord a => a -> [a] -> ([a], [a], [a])
разделить_относительно числа список = ( -- на три части
  -- первая часть: числа, меньшие числа
  отобрать (меньше числа) список,
  -- вторая часть: числа, равные данному числу
  отобрать (равные числа) список, -- ок, промашка в падеже
  -- третья часть: числа, большие числа
  отобрать (больше числа) список
  )
  where
    -- синонимы
    отобрать = filter
    меньше = (>)
    больше = (<)
    равные = (==)

*Main> разделить_относительно 2 [1,2,3,4,5]
([1],[2],[3,4,5])

split3 :: Ord a => a -> [a] -> ([a],[a],[a])
split3 _ [] = ([],[],[])
split3 y (x:xs) | x < y  = (x:z1, z2, z3)
                | x == y = (z1, x:z2, z3)
                | x > y  = (z1, z2, x:z3)
                    where (z1,z2,z3) = split3 y xs
                
main = print $ split3 2 [1,2,3,4,5]

task :: [Integer] -> Integer -> [[Integer]]
task x n = foldl (\ acc z -> g z acc) [[],[],[]] x
           where g z [a1,a2,a3] | (z <n) = [z:a1,a2,a3]
                                | (z==n) = [a1,z:a2,a3]
                                | otherwise = [a1,a2,z:a3]

{-#Language LambdaCase#-}
import Data.Function
 
while :: k -> (k -> (Bool, k)) -> k
while k g = fix (\f -> \case
    (True, x)  -> f.g $ x
    (False, x) -> x) $ (True, k)
 
stop = False
retry = True
 
task :: Int -> [Int] -> ([Int],[Int],[Int])
task k s = (a,b,c)
  where
    (a,b,c,_)=  while ([],[],[],s) $ \case
        (a,b,c,[])            -> (stop,  (a,b,c,s))
        (a,b,c,x:xs) | x <  k -> (retry, (x:a,b,c,xs))
                     | x == k -> (retry, (a,x:b,c,xs))
                     | x >  k -> (retry, (a,b,x:c,xs))