Получить из списка - список списков

q = "papa#mama"
 
tt' :: Int -> Int -> String -> String
tt' _ _ []    = []
tt' m k (x:s) | m>0 = tt' 0 0 (drop m (x:s)) 
              | x=='#' = []
              | x/='#' = x : tt' 0 (k+1) s

stringList string = buildList string '' []
 
buildList string@(sym:syms) word list = | string == [] = list
                                     | sym == '#' = buildList syms '' (list ++ word)
                                     | otherwise = buildList syms (word ++ sym) list

-- позиция символа с в строке x
 
indStr :: Char -> String -> Int
indStr c ini@(x:xs) = if (c `elem` ini) then 
                          if (c == x) then 1
                          else 1 + (indStr c xs)
                      else
                          0
 
strList :: String -> [String]
strList []=[]
strList x = if ix == 0 then [x]
            else (take (ix-1) x) : strList (drop ix x)
            where ix=(indStr '#' x)
 
Main> strList "qwe#yyy#iii#"
 
["qwe","yyy","iii"]

import Data.List (break)
 
f :: String -> [String]
f xs =
    let (a, b) = break (=='#') xs in
    a : if null b then [] else f (tail b)

import Data.List (break)
 
g :: Eq a => a -> [a] -> [[a]]
g c xs =
    let (a, b) = break (==c) xs in
    a : if null b then [] else g c (tail b)
 
f :: String -> [[String]]
f = g "" . g '#'

Main> f "water#ice#fire##red#green#blue"
[["water","ice","fire"],["red","green","blue"]]

convStr :: String -> String -> [String]
 
convStr [] _ = []
convStr (x:xs) y = if (x == '#') then y : convStr xs []
                                 else convStr xs (y ++ [x])
 
 
Main> convStr "qqq#uuu#bbb#" []
 
["qqq","uuu","bbb"]

convStr :: String -> String -> [String]
 
convStr [] y = [y]  -- чтобы корректно обрабатывать случай, когда в конце строки нет #
convStr (x:xs) y = if (x == '#') then y : convStr xs []
                                 else convStr xs (y ++ [x])
 
 
Main> convStr "qqq#uuu#bbb#" []
 
["qqq","uuu","bbb"]

convStrR :: String -> String -> [String]
convStrR y [] = [y]
convStrR y (x:xs) =
    if (x == '#')
    then y : convStrR [] xs
    else convStrR (x:y) xs
    
 
convStr :: String -> [String]
convStr = map reverse . convStrR []

convStr :: String -> String -> [String]
convStr [] y = [y]
convStr (x:xs) y = if (x == '#') then y : convStr xs []
                                 else convStr xs (y ++ [x])
 
convStr2 :: String -> String -> [String]
convStr2 [] y = [y]
convStr2 (x:xs) z = if (x == '#') && (take 1 xs == "#") then  z : convStr2 (drop 1 xs) []
                                                        else convStr2 xs (z ++ [x])  
 
f :: String -> [String]
f x = convStr x []
 
task :: String -> [[String]]
task x = map f (convStr2 x [])
 
Main> task "aaa#bbb##ccc#ddd##eee"
[["aaa","bbb"],["ccc","ddd"],["eee"]]

convListR :: Eq a => a -> [a] -> [a] -> [[a]]
convListR c y [] = [y]
convListR c y (x:xs) =
    if (x == c)
    then y : convListR c [] xs
    else convListR c (x:y) xs
 
convStr :: String -> [[String]]
convStr = convListR [] [] . map reverse . convListR '#' []

import Text.ParserCombinators.ReadP
 
test = foldr (const . fst) [] . readP_to_S read_p
  where
    read_p = do xs <- sepBy (sepBy (many get) $ char '#') $ string "##"
                eof
                return xs

{-# LANGUAGE OverloadedStrings #-}
 
import Data.Text (split, Text (..))
import Data.List (groupBy)
import Data.Functor ((<$>))
 
groupWords :: Text -> [[Text]]
groupWords = filter (not . null) . map (filter (/= "")) <$> groupBy (const (/= "")) . split (== '#')

*Main> :set -XOverloadedStrings
*Main> groupWords "red#blue#green#water#fire"
[["red","blue","green","water","fire"]]
*Main> groupWords "red#blue#green#water#fire#" -- trailing '#'
[["red","blue","green","water","fire"]]
*Main> groupWords "red#blue#green##water#fire#" -- groups separator
[["red","blue","green"],["water","fire"]]
*Main>

import Data.List.Split
 
groupWords :: String -> [[String]]
groupWords = map (wordsBy (== '#')) . splitOn "##"

*Main> groupWords "red#green#blue##water#fire#"
[["red","green","blue"],["water","fire"]]