dmz>>process (inp filt group_by consume) = inp >>> filter filt >>> group group_by >>> consume
dmz>>

NGG>вставив внутрь строчки для органиции потока данных по этой цепочке, я тоже разом решу все возможные проблемы?

runDialog [
  Editbox [Color := Red, Label := "Speed", Init := (do setText =<< readVar speed), 
                                           OnOK := (do getText >>= writeVar speed)]
  SpinButton ....
]

NGG>Гхм. Тут какое-то расхождение во взглядах на то, что такое монолитность

а моё комбинируется из нескольких функций для полученя нужного результата и каждая из этих функций может жить счастливой самостоятельной жизнью.

NGG>Хитрожопую группу, которую простым фильтром не получить Н-р, нужно помнить состояние, а это меняет интерфейс группировалки...

type Group a b = [a] -> ([([a], [a] -> b)], [a])
passFirst g s = g s
passAll g s = (fst $ g s, s)
makeGroup :: (Eq a) => ([a] -> [a]) -> ([a] -> b) -> Group a b
makeGroup f p l = ([(m, p)], l \\ m) where m = f l
composeGroup p f n [] = ([], [])
composeGroup p f n l = (fg ++ ng, ntail) where
    (fg, ftail) = p f l
    (ng, ntail) = p n ftail
seqGroup :: (Eq a) => Group a b -> Group a b -> Group a b
seqGroup = composeGroup passFirst
unionGroup :: (Eq a) => Group a b -> Group a b -> Group a b
unionGroup = composeGroup passAll

groupAndProcess input grouping = mapM_ (\x -> (snd x) (fst x)) $ fst $ grouping input

-- Остальное ниже - семечки, к делу не относящиеся
groupCmp cmp [] = []
groupCmp cmp l@(s:_) = filter (cmp s) l
groupByWith cmp x = seqGroup (makeGroup (groupCmp cmp) x) (groupByWith cmp x)

consoleOutput prefix input = putStrLn prefix >> mapM_ (putStrLn . ("\t" ++)) input

byFirstLetter :: String -> String -> Bool
byFirstLetter _ [] = False
byFirstLetter [] _ = False
byFirstLetter (l:_) (r:_) = l == r
groupStated f i l = map fst $ filter snd $ zip l $ fst $ runState (mapM f l) i
statedFilter :: String -> State String Bool -- группировалка со стейтом
statedFilter s = do
    lastStr <- get
    if ((null lastStr) || (null s) || ((last lastStr) == head s))
        then do
            put s
            return True
        else return False
input = ["abc", "cde", "efg", "aaa", "ghi", "sxdf", "zadedf", "sfsfg", "atrhyh", "43f5", "sdcsby", "Unuufd"]

main = groupAndProcess input $ unionGroup -- union, т.е. элементы попадут в обе группы
    (makeGroup (groupStated statedFilter "") (\xs@(x:_) -> consoleOutput [head x] xs)) -- составляем цепочку слов
    (groupByWith byFirstLetter (\xs@(x:_) -> consoleOutput [head x] xs)) -- группируем по первому символу

1. Основной код всё равно невелик, 15 строк
2. Либо всё это пишется проще на порядок (хотелось бы тогда от гуру увидеть подтверждение)
3. И проще решать частные задачи по 2 строки на каждую, чем делать такое обобщение, которым и пользоваться не будет никто

byFirstLetter :: String -> String -> Bool
byFirstLetter _ [] = False
byFirstLetter [] _ = False
byFirstLetter (l:_) (r:_) = l == r

makeChain strs = reverse $ makeChain' strs "" [] where
    makeChain' [] cur acc = acc
    makeChain' (c:cs) cur acc
        | isPrefixOf cur c = makeChain' cs [last c] (c:acc)
        | otherwise = makeChain' cs cur acc
main = consoleOutput "chain" chain >> mapM_ (\xs@(x:_) -> consoleOutput [head x] xs) groups where
    (chain, groups) = (makeChain &&& (groupBy byFirstLetter . sort)) input

class UniqueFilter<T> implements IFilter<T> {
    private Collection<T> uniqueData = ...
    UniqueFilter(IFilter<T> filter) {
       ...
    }
    
    UniqueFilter() {
       ...
    }

    boolean add(T t) {
       ...
    }
}

interface IFilter<T>
{
    boolean match(T t);
}

dmz>process inp filt group_by consume = inp >>> filter filt >>> group group_by >>> consume

NGG>сlass TaskNumberOne {
NGG>void process(Source inp, Filter filt , Group group_by, Consumer consume)  {...}
NGG>}

сlass TaskNumberOne {
  template <class Source, class Filter, class Group, class Consumer>
  void process(Source inp, Filter filt, Group group_by, Consumer consume)  {...}