Разделение списка Split

split' :: (Eq a) => a -> [a] -> [a] -> [[a]]
split' _ [] acc = [acc]
split' d (y:ys) acc | (y == d) = acc : (split' d ys []) 
                    | otherwise = split' d ys (acc ++ [y])
                    
split :: (Eq a) => a -> [a] -> [[a]]
split d x = split' d x []
 
Main> split ',' "a,b,c"
["a","b","c"]
 
Main> split 2 [1,2,3,2,4,4,2,5]
[[1],[3],[4,4],[5]]

split :: Eq a => a -> [a] -> [[a]]
split d = snd . splt 
  where splt xs = case brk xs of
                        ([],f) -> ([],[f])
                        (r,f) -> (f:) <$> splt r 
        brk [] = ([],[])
        brk (x:xs) | x==d = (xs,[])
        brk (x:xs) = (x:) <$> brk xs

{-# LANGUAGE ViewPatterns #-}
split :: Eq a => a -> [a] -> [[a]]
split d = snd . splt 
  where splt (brk ->(r,f)) | null r = ([],[f])
                           | otherwise = (f:) <$> splt r 
        brk [] = ([],[])
        brk (x:xs) | x==d = (xs,[])
        brk (x:xs) = (x:) <$> brk xs

import Data.List
 
split :: Eq a => a -> [a] -> [[a]]
split _ [] = []
split d l  = uncurry (:) . fmap (split d . drop 1) . break (==d) $ l

import qualified Data.List.Split as S -- пакет split
-- или import qualified Data.List.Extra as E -- пакет extra
 
split :: Eq a => a -> [a] -> [[a]]        
split d = S.splitWhen (d==)
       -- E.split

split' :: (Eq a) => a -> [a] -> [a] -> [[a]]
split' _ [] acc = [acc]
split' d (y:ys) acc | (y == d) = acc : (split' d ys []) 
                    | otherwise = split' d ys (acc ++ [y])
                    
split :: (Eq a) => a -> [a] -> [[a]]
split d x = split' d x []

split' :: (Eq a) => a -> [a] -> [a] -> [[a]] -- сигнатура функции  
-- параметры:
-- 1) разделяющий элемент
-- 2) расщепляемый список
-- 3) накопительный параметр
split' _ [] acc = [acc]  -- терминальная ветвь рекурсии (когда список исчерпан - возвращаем то, что накопили)
split' d (y:ys) acc | (y == d) = acc : (split' d ys [])  -- если первый элемент совпадает с разд. элементом,
                                                                      -- выносим в начало то, что накопили, и продолжаем расщепление
                                                                      -- с пустым накопителем
                    | otherwise = split' d ys (acc ++ [y]) -- иначе продолжаем расщепление, добавив первый эл-т в хвост 
                                                                      -- накопителя
                    
split :: (Eq a) => a -> [a] -> [[a]]  -- это просто обертка для функции, описанной выше (чтобы при запуске
split d x = split' d x []                   -- не задавать лишних параметров