words.
    group_by{|word| word[0]}.
    each{|letter, group| File.open(letter, 'w').write(group.join("\n"))}

def dir_contents(dir)
  pathes.
    select{|path| in_dir?(path, dir)}.
    map{|path| first_path_element(relative_path(path, dir))}.
    uniq.
    partition{|path| is_dir?(path)}
end

# вспомогательные функции могут выглядеть так (а могут, например, работать с объектами файловой системы)
def in_dir?(path, dir)
  path.index(dir) == 0
end

def is_dir?(path)
    path =~ /\\$/
end

def relative_path(path, relative_to)
    path.sub(/^#{relative_to}\\/, '')
end

def first_path_element(path)
    path.sub(/^(\w+?)(?:(\\)\w*)?$/, '\1\2')
end

Г>>

        |dir2 => file2
dir1 => |dir3 => file3
        |file1
dir4 => file4

dirlist = pathes.
  group_by{|path| first_path_element(path)}.                        #складываем по папкам
  map{|dir, group| [dir, group.map{|path| relative(path, dir)}]} #откусываем имя папки, в которую положили

def dir_contents(dir)
  res = dirlist.detect{|d, path| d == dir}
  res && res.last || [] #last - в смысле, из массива [папка, [содержимое папки]]
end

dirlist_hash = dirlist.to_hash

def dir_contents(dir)
  dirlist_hash[dir]
end

AMOUNT = 1024 * 1024

#исхожу из того, что stream.read сдвигает указатель начала входного потока
def compress4(stream)
  stream.
    #превращаем поток в массив массивов из 4х элементов по 1 Мб
    unfold{|stream| stream.empty? ? nil : [(1..4).map{stream.read(AMOUNT)}, stream]}. 
    #сжимаем, исходя из того, что map у нас достаточно умен для распараллеливания ;)
    #и сразу склеиваем 4 сжатых кусочка в 1
    map{|four_chunks| four_chunks.map{|chunk| compress(chunk)}.join}.
    join        #...и склеиваем все
end

import Char
import List

main = do
    ls <- readFile "word.txt"

    let fs = words ls
          |> sortBy  (\(x:_) (y:_) -> toLower x `compare` toLower y)
          |> groupBy (\(x:_) (y:_) -> x == y)
          |> filter  (\((x:_):_)   -> isAlpha x)

    mapM_ (\f@((c:_):_) -> writeFile [c] $ unlines f) fs


infixl 0 |>
x |> f = f x

import List

dirs = [ "dir1\\file1"
       , "dir1\\dir2\\file2"
       , "dir1\\dir3\\file3"
       , "dir4\\file4"
       ]

slash2tab c = if c == '\\' then "\\\t" else [c]

dirs' = map (\d -> words $ (concat $ map slash2tab d)) dirs

f'a dir = filter (\(d:_) -> init d == dir) dirs'
       |> map tail
       |> (\xs -> ( concat $  filter (\(x:_) -> last x /= '\\') xs
                  , filter (\(x:_) -> last x == '\\') xs
                    |> map (init.head)))


infixl 0 |>
x |> f = f x

dir1\file1
dir1\dir2\file2
dir1\dir3\file3
dir4\file4

f ""          = ([],        ["dir1","dir4"])
f "dir1"      = (["file1"], ["dir2","dir3"])
f "dir1\dir2" = (["file2"], [])

open Std
open ExtList.List
open ExtString

(* group -  нигде нет *)
let rec group f l = match l with
     | x::xs -> let m,n = partition (fun y -> (f x) = (f y)) xs in [x :: m] @ group f n
     | []    -> []

let words = 
    (* isAlpha тоже нигде нет *)
    let filt  x = let good = function 
        | 'a' .. 'z' | 'A' .. 'Z' -> true
        | _                       -> false
        in (filter (fun a -> a <> "" &&  good a.[0]) x) in
    let read    = input_list stdin
    in group (fun x -> x.[0]) (filt read)

let _ = iter ( fun x -> output_file (String.sub (hd x) 0 1) (String.join "\n" (x)) ) words

dmz@x200:~/prj/ocaml/shit$ wc -l ./filez 
67406 ./filez
dmz@x200:~/prj/ocaml/shit$ time cat filez  | ./a.out 

real    0m0.201s
user    0m0.176s
sys    0m0.028s

let (|>) x f = f x;;

let words = ["Not"; "so"; "long"; "list"; "of"; "9-10"; "not"; "so"; "weird"; "words"];;

let idx s =
  if s<>"" then
    if s.[0]>='A' && s.[0]<='Z' then Some( (int_of_char s.[0]) - 65 ) else
    if s.[0]>='a' && s.[0]<='z' then Some( (int_of_char s.[0]) - 97 ) else None
  else None;;
  
let group lst =
  let a = Array.make 26 [] in
  List.iter (fun s-> match idx s with Some i -> a.(i) <- s::a.(i) | None -> ()) lst; a;;
  
let write =
  Array.iteri (fun i lst -> if lst <> [] then 
    Std.output_file ~filename:(i+97 |> char_of_int |> Std.string_of_char) 
                    ~text:(String.concat "\n" (List.rev lst)));;

words |> group |> write;;

vector<string> words;

for(int i = 0, end = words.size(); i != end; ++i)
{
   ofstream(words[i].substr(0,1).c_str(), ios::app) << words[i] << ' ';
}

ofstream* ofs[26];

for(char c = 'a'; c <= 'z'; ++c)
{
    ofs[c - 'a'] =  new ofstream(string(1, c).c_str());
}

vector<string> words;

for(int i = 0, end = words.size(); i != end; ++i)
{
    *ofs[words[i][0] - 'a'] << words[i] << ' ';
}

open Std
open ExtList.List
open ExtString
open ExtHashtbl


let group l = 
    let hsh =  Hashtbl.create 1000 in
    let k s = if String.length s > 0 && ((s.[0] >= 'A' && s.[0] <= 'Z') || (s.[0] >= 'a' && s.[0] <= 'z'))
              then String.sub s 0 1 else "" in
    let step x = let key = k x in
                 if not (Hashtbl.exists hsh key) then Hashtbl.add hsh key (x::[])
                 else let item = Hashtbl.find hsh key in Hashtbl.replace hsh key (x::item)
    in Enum.iter step l ; hsh

let _ = 
    let hsh = group (input_lines stdin) in
    Enum.iter ( fun x -> if x <> "" then output_file x (String.join "\n" (Hashtbl.find hsh x) )) (Hashtbl.keys hsh)

open Std
open ExtList.List
open ExtString

(* group -  нигде нет. тормозно, но можно переписать на хэшах - будет быстро. *)
let rec group f l = match l with
     | x::xs -> let m,n = partition (fun y -> (f x) = (f y)) xs in [x :: m] @ group f n
     | []    -> []

let dump_words = 
    let good c = match c with 
        | 'A' .. 'Z' -> c
        | 'a' .. 'z' -> c
        | _ -> '_' in
    let sanitize x = String.map good x in
    let fname x  = sanitize (if String.length x >= 3 then String.sub x 0 3 else x) in
    let read     = input_list stdin in
    let filt l   = filter (fun s -> s <> "") l in
    let dump = iter ( fun x -> output_file (fname (hd x)) (String.join "\n" (x)) ) 
    in dump (group fname (filt read))

let _ = dump_words

BB>Вариант №1. Do not optimize prematurely...

#include <vector>
#include <iostream>

using namespace std;

int main(int,char**)
{
    vector<string> words;

    for(int i = 0, end = words.size(); i != end; ++i)
    {
       ofstream(words[i].substr(0,1).c_str(), ios::app) << words[i] << ' ';
    }

}

dmz@x200:~/prj/ocaml/shit$ g++ ./t10cc.cc 
./t10cc.cc: In function ‘int main(int, char**)’:
./t10cc.cc:12: error: invalid use of incomplete type ‘struct std::ofstream’
/usr/include/c++/4.3/iosfwd:89: error: declaration of ‘struct std::ofstream’

vector<string> words;

sort(words.begin(), words.end(), Less3);

vector<string>::iterator upper, cur = words.begin(), end = words.end();

while(cur != end)
{
    upper = upper_bound(cur, end, *cur, Less3);
    
    ofstream ofs(cur->substr(0,3).c_str());

    while(cur != upper)
    {
        ofs << *cur++ << ' ';
    }
}

bool Less3(std::string const& l, std::string const& r)
{
  return l.substr(0,3) < r.substr(0, 3);
}

BZ>>вот и напишите этот map

Г>Ой нет. Эт я даже не представляю, с чего начинать. В смысле, если писать на Рубях, нужна видимо какая-то библиотека для параллельности, а я такими вопросами не задавался

module Enumerable
    def parallel_map(&block)
        results = []
        threads = self.to_enum(:each_with_index).
            map{|obj, i| Thread.new{results[i] = block.call(obj)} }.each{|t| t.join}
        
        results
    end
end

#тестируем
r = [1,2,3,4,5].parallel_map{|i| p Thread.current; i+5}
p r

#<Thread:0x297db6c run>
#<Thread:0x297da18 run>
#<Thread:0x297d900 run>
#<Thread:0x297d7e8 run>
#<Thread:0x297d6d0 run>
[6, 7, 8, 9, 10]

BZ>ну понятно же, что меньше O(N) на самом списке не получишь

/dir1/subdir1/subsubdir1
/dir1/subdir2/subsubdir2
...

open Std
open ExtList.List
open ExtString

let delim = "/"

let spath s = filter (fun x -> x <> "") (String.nsplit s delim)

let rec group f l = match l with
     | x::xs -> let m,n = partition (fun y -> (f x) = (f y)) xs in [x :: m] @ group f n
     | []    -> []

let gen_p p =
    let path = spath p in
    let ml = length path 
    in let rec ggen l path  = 
            if l < ml then (String.join delim (take l path), nth path (l)) :: ggen (l+1) path
            else (String.join delim (take l path), "")::[]
    in ggen 1 path


let gen_all l = map ( fun x -> (fst (hd x), map snd x )) (group fst (fold_left (@) [] (map gen_p l)))

(* можно хэш построить,  но лень -  суть понятна *)
let _ = List.accos "home" gen_all (input_list stdin)

#include <string>
#include <fstream>
#include <map>

typedef std::map<std::string, std::string> StringToString;

int main(int /*argc*/, char* /*argv[]*/)
{
    using namespace std;

    StringToString m;

    ifstream in("corncob_lowercase.txt"); // http://www.mieliestronk.com/corncob_lowercase.zip

    string temp;    

    while(in >> temp)
        m[temp.substr(0,3)].append(temp).append("\n");

    for(StringToString::iterator i = m.begin(), end = m.end(); i != end; ++i)
    {
        ofstream out(i->first.c_str());
        out << i->second;
    }

    return 0;
}

-- (* RAII facilities *)
fun unwind_protect(thunk, cleanup) ->
  local ok, result = pcall(thunk)
  if cleanup then cleanup() end
  if not ok then error(result,0) else return res end
end

fun with_open_file(path,mode) ->
  fun (body) ->
    local file = assert(io.open(path,mode))
    return unwind_protect(fun()-> body(file) end, =>file:close())
  end
end

fun with_file_list() ->
  fun (body) ->
    local flist = {}
    return unwind_protect(
      fun()-> body(flist) end,
      fun()-> 
        for _,file in pairs(flist) do file:close() end 
      end)
  end
end

-- (* '$' работает как в Haskell *)
-- (* '=>' делает thunk из выражения справа: '=> expr' тоже самое, что: 'fun() -> expr end' *)
print$pcall$=>
with_open_file("words.txt","rb")$fun (infile) ->
  local words = infile:read("*a")
  return with_file_list()$fun (filelist) ->
    for word, first in words:gmatch"((%a)%a*)" do
      filelist[first] or= assert(io.open(first..".txt","wb"))
      filelist[first]:write(word,'\n')
    end
  end
end

bash$ hluago wordlist.hlua
true    nil
bash$ tail -n 3 j.txt
juxtaposition
juxtapositional
juxtapositions

import heapq

def makeHuffTree(symbolTupleList):
    trees = list(symbolTupleList)
    heapq.heapify(trees)
    while len(trees) > 1:
        childR, childL = heapq.heappop(trees), heapq.heappop(trees)
        parent = (childL[0] + childR[0], childL, childR)
        heapq.heappush(trees, parent)
    return trees[0]

ofstream *handles[26]
...
for( ... ) 
{
   handles[i] = new ofstream(...);
}
...

BZ>при всём нашем уважении к питону это построитель дерева, а не генератор кодов

# module Huffman : sig
    val encode : (int * int) list -> string -> (bool -> unit) -> unit
    val decode : (int * int) list -> (unit -> bool option) -> string
  end = struct
    type node =
      | Leaf of int
      | Node of t * t
    and t = int * node
  
    let rec build roots =
      match List.sort compare roots with
      | [] -> invalid_arg "Huffman"
      | [h] -> h
      | (p1, _ as t1)::(p2, _ as t2)::t ->
          build((p1 + p2, Node(t1, t2)) :: t)
  
    let mk_tree freqs =
      build((0, Leaf(-1))::List.map (fun (p, c) -> p, Leaf c) freqs)
  
    let rec mk_table = function
      | _, Leaf c -> [c, []]
      | _, Node(t1, t2) ->
          let cons b (c, t) = c, b::t in
          List.map (cons true) (mk_table t1) @
            List.map (cons false) (mk_table t2)
  
    let encode freqs string write_bit =
      let table = mk_table(mk_tree freqs) in
      let rec emit char =
        let byte = Char.code char in
        List.iter write_bit (List.assoc byte table) in
      String.iter emit string;
      List.iter write_bit (List.assoc (-1) table)
  
    let rec decode_aux read_bit t tree buf =
      match t with
      | _, Leaf(-1) -> Buffer.contents buf
      | _, Leaf byte ->
          Buffer.add_char buf (Char.chr byte);
          decode_aux read_bit tree tree buf
      | _, Node(t1, t2) ->
          match read_bit(), t1, t2 with
          | None, _, _ -> invalid_arg "decode"
          | Some true, t, _ | Some false, _, t ->
              decode_aux read_bit t tree buf
  
    let decode freqs read_bit =
      let tree = mk_tree freqs in
      decode_aux read_bit tree tree (Buffer.create 1024)
  end;;
module Huffman :
  sig
    val encode : (int * int) list -> string -> (bool -> unit) -> unit
    val decode : (int * int) list -> (unit -> bool option) -> string
  end

import System.IO
import Data.List

input = ["abc", "def", "ijk", "axxx", "der", "preved", "%%%%%", "12345"]

main = mapM_ print [(fileName, listOfWords) | fileName <- map (:[]) ['a'..'z'],  
                                              listOfWords <- [filter (isPrefixOf fileName) input], 
                                              length listOfWords > 0]

interface IGroup<T>
{
    boolean add(T data); //true - data accepted, false - not accepted.

    void done(); //no more data, group finished.
}

//обработчик произвольных данных 
interface IProcessor<T>
{
    void add(T data); 
    void done(); //no more data
}

//пишет в файл
class FileProcessor implements IProcessor<String> 
{
    FileProcessor(String fileName) { ... }
    ...
}
//пишет в консоль
class ConsoleProcessor implements IProcessor<String> 
{
    ConsoleProcessor(String prefix) { ... }
    ...
}

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

//фильтр по первой букве
class ByFirstLetter implements IFilter<String>
{
    ByFirstLetter(char letter) {...}
    ...
}

//фильтрует и обрабатывает данные 
class FilteredGroup<T> implements IGroup<T>
{
    private IProcessor<T> processor;
    private Filter<T> filter;

    public FilteredGroup(IProcessor<T> processor, Filter<T> filter)
    {
        this.processor = processor;
        this.filter = filter;
    }

    public boolean add(T t)
    {
        if (filter.match(t))
        {
            processor.add(t);
            return true;
        }
        return false;
    }

    public void done()
    {
        processor.done();
    }
}

class СompositeSeqGroup<T> implements IGroup<T>
{
    private ArrayList<IGroup<T>> groups;

    СompositeSeqGroup(List<IGroup<T>> groups)
    {
        this.groups = new ArrayList<IGroup<T>>(groups);
    }

    public boolean add(T t)
    {
        for (int i = 0; i < groups.size(); i++)
        {
            if (groups.get(i).add(t))
            {
                return true;
            }
        }
        return false;
    }

    public void done()
    {
        for (int i = 0; i < groups.size(); i++)
        {
            groups.get(i).done();
        }
    }
}

    public static void main(String[] args)
    {
        ArrayList<IGroup<String>> groups = new ArrayList<IGroup<String>>();
        for (char letter = 'a'; letter <= 'z'; letter++)
        {
            groups.add(new FilteredGroup<String>(new FileProcessor(Character.toString(letter)), //new ConsoleProcessor(Character.toString(letter)), 
                                                 new ByFirstLetter(letter)));
        }
        
        IGroup<String> group = new CompositeSeqGroup<String>(groups)
 
        //Этот код может быть вынесен в класс CompositeSeqGroup, дабы не повторяться...
        for (int i = 0; i < args.length; i++)
        {
            group.add(args[i]);
        }
        group.done();
    }

(>>==) = flip fmap

---------------------------------------------------------------------------------------------------
---- Операции над списками ------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------

-- |Sort and Group list by function result
sort_and_groupOn  f  =  groupOn f . sortOn  f
sort_and_groupOn' f  =  groupOn f . sortOn' f

-- |Sort list by function result (use Schwarznegian transform)
sortOn  f  =  map snd . sortOn' fst . map (keyval f)

-- |Sort list by function result (don't use Schwarznegian transform!)
sortOn' f  =  sortBy (map2cmp f)

-- |Group list by function result
groupOn f  =  groupBy (map2eq f)

-- Utility functions for list operations
keyval  f x    =  (f x, x)                -- |Return pair containing computed key and original value
map2cmp f x y  =  (f x) `compare` (f y)   -- |Converts "key_func" to "compare_func"
map2eq  f x y  =  (f x) == (f y)          -- |Converts "key_func" to "eq_func"

input = input_list

filter = filter ( start_with "[:digit:|:letter:]" ) 

preprocess x = x

by_prefix = ...

output = (* открываем файл и пишем, как-то так: *) iter ( fun x -> output_file (mk_fname) (String.join "\n" (x)) )

do_job_with x = input x >>> filter >>> preprocess >>> group by_prefix >>> output

import Data.List

lst = [
  "dir1\\file1", "dir1\\dir2\\file2", "dir1\\dir3\\file3", "dir4\\file4"]

f lst d = (files, nub [takeWhile (/='\\') x | x <- dirs])
  where
    ff [] = lst
    ff xs = [drop ld x | x <- lst, take ld x == dd]
    dd = d ++ "\\"
    ld = length dd
    (files, dirs) = partition (notElem '\\') $ ff d

f list dir = list
  .$ mapMaybe (stripPrefix (make dir))         -- отберём элементы внутри каталога dir
                                               --   и отрежем от них префикс dir\
  .$ partition ('\\' `notElem`)                -- разделим на файлы и каталоги
  .$ mapSnd (nub . map (takeWhile (/='\\')))   -- удалим дубликаты из списка каталогов

-- Добавить \ к имени каталога, если оно непустое
make ""  = ""
make dir = dir++"\\"

-- Функция, которая у других авторов обозначается как |>
-- В общем-то, заменяет нам вызов метода класса :)
a.$f = f a

-- Ещё одна функция из моей станд. библиотеки
mapSnd f (a,b) = (a, f b)

filterGroup :: [a] -> [(a -> Bool, a -> b)] -> [([a], a -> b)]
filterGroup _ [] = []
filterGroup d (x:xs) = (fst part, snd x) : (filterGroup (snd part) xs) where
    part = partition (fst x) d

stdOutput :: (Show a) => String -> a -> IO ()
stdOutput s x = do
    putStr $ s ++ ": "
    print x

processGroups :: [a] -> [(a -> Bool, a -> b)] -> [[b]]
processGroups d f = map (\x -> map (snd x) (fst x)) $ filterGroup d f
processGroupsIO d f = mapM_ sequence_ $ processGroups d f

filters :: [(String -> Bool, String -> IO ())]
filters = [(('a' `elem`), stdOutput "a"), (('a' `notElem`), stdOutput "not a"), (null, stdOutput "empty")]
theData = ["ala", "dfkja", "jrgh", "", "sejhr", "drt"]

main = let
    byFirstLetter c [] = False
    byFirstLetter c (x:xs) = x == c
    makeFilter :: Char -> (String -> Bool, String -> IO ())
    makeFilter c = (byFirstLetter c, stdOutput [c])
    groups = map makeFilter ['a'..'z']
    in
        processGroupsIO theData groups

-- твой же код, но слегка причёсанный (к вопросу о том, что практики принятые в грустном императивном мире полезны не только в нём) 
type IFilter a = a -> Bool
type IProcessor a b = a -> b
type FilteredGroup a b = (IFilter a, IProcessor a b)
 
applyFilteredGroups :: [a] -> [FilteredGroup a b] -> [([a], IProcessor a b)]
applyFilteredGroups _ [] = []
applyFilteredGroups items ((gFilter, gProcessor):groups) = 
   (matchedItems, gProcessor) : (applyFilteredGroups unmatchedItems groups) 
    where
        (matchedItems, unmatchedItems) = partition gFilter items

processGroups :: [a] -> [FilteredGroup a b] -> [[b]]
processGroups d f = map (\x -> map (snd x) (fst x)) $ applyFilteredGroups d f

processGroupsIO d f = mapM_ sequence_ $ processGroups d f

makeStdOutput :: (Show a) => String -> IProcessor a (IO())
makeStdOutput s x = do
    putStr $ s ++ ": "
    print x

makeByFirstLetter :: Char -> IFilter String
makeByFirstLetter c = isPrefixOf [c]

makeGroupFromChar :: Char -> FilteredGroup String (IO())
makeGroupFromChar c = (makeByFirstLetter c, makeStdOutput [c])

main = processGroupsIO theData $ map makeGroupFromChar ['a'..'z']

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

less2cmp (<) a b | a < b = LT
                 | b < a = GT
                 | True  = EQ

lt a b = if less a b then LT else EQ

lt a b = if less a b then LT else GT

VE>Ну зато операцию < можно развернуть в обратную сторону, тогда можно получить все три варианта

cmp p a b | a `p` b   = LT
          | b `p` a   = GT
          | otherwise = EQ

xs = [ 0, 9, 1, 8, 2, 7, 3, 6, 4, 5 ]

ys = sortBy (cmp (<)) xs -- [0,1,2,3,4,5,6,7,8,9]
zs = sortBy (cmp (>)) xs -- [9,8,7,6,5,4,3,2,1,0]

main = do readFile "words" >>== words >>== split2groups (map contains ['a'..'z']) >>== zip ["a".."z"]
            >= mapM_ (\filename list -> writeFile filename (unwords list))

NGG>"не боясь запутаться" — это, как мне кажется, относится только к "чистым" функциям без сайд эффектов и всяких lazy-хитростей. Иначе всё равно буду бояться

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

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

NGG>Т.е. утверждение, что "очень легко и красиво решаются" неверно?

filter_a = ...
filter_b = ...
filter_c = ...

do_the_job input >>> (filter_a . filter_b . filter_c ) >>> group >>> consume

ну или 

mega_filter = filter_a . filter_b . filter_c

Решение адын:

class FilterA : Filter { десять строк }
class FilterB : Filter { десять строк }
class FilterB : Filter { десять строк }

class MegaFilter : Filter 
{
   bool apply( Entity entity ) {
      return FilterA(entity) && FilterB(entity) && FilterC(entity)
   }
};

Решение два:

class MegaFilter : Filter 
{
   MegaFilter( List<Filter>& filt ) {}

   bool apply( Entity entity ) {
      foreach( ... ) {  ... }
   }
};

Решение три - рефакторим интерфейсы

NGG>Но если решается "реальная" задача (а не игрушечная), имеет смысл обобщить слегка задачу, чтобы перекрыть себе тылы на случай изменений в требованиях. Поэтому я привёл обобщённый вариант нашей игрушечной задачи и его решение в оо-стиле. Это тоже игра Смысл игры в том, чтобы показать как "тупое" ооп может привести к многословному, но достаточно гибкому решению.

superMain infile tokenizer detokenizer grouper = 
  readFile infile >>== tokenizer >>== sort_and_group_on grouper
    >>= mapM_ (\list -> writeFile (grouper (head list)) (detokenizer list))

BZ>>>main = do readFile "words" >>== words >>== sort_and_groupOn (take 3) 
            >>>>= mapM_ (\list -> writeFile (take 3 (head list)) (unwords list))

BZ>main = do readFile "words" >>== words >>== split2groups (map contains ['a'..'z']) >>== zip ["a".."z"]
            >>= mapM_ (\filename list -> writeFile filename (unwords list))
BZ>

a :: Int -> Strig
b :: String->Int

a':: Int -> Strig
b':: String->Int

с:: (Int -> String) -> (String -> Int) -> String(неважно что) -> String (в неважно что)

data Converter = Converter 
{
     encoder :: (Int->String), 
     decoder :: (String -> Int)
}

c :: Converter -> String(неважно что) -> String (в неважно что)

BZ>я сужу по своему опыту. а ты судишь по отсутствию опыта

        //Создание фильтров         
        ArrayList<IGroup<String>> groups = new ArrayList<IGroup<String>>();
        for (char letter = 'a'; letter <= 'z'; letter++) //да, заменить for на map было бы приятно... но суть не меняется.
        {
            groups.add(new FilteredGroup<String>(new FileProcessor(Character.toString(letter)),
                                                 new ByFirstLetter(letter)));
        }
        
        //Задание приоритетов 
        IGroup<String> group = new CompositeSeqGroup<String>(groups);
             
        //обработка
        //место этого цикла, как я уже говорил, не правильное. он должен жить в дефолтной реализации метода IGroup#addAll()
        for (int i = 0; i < args.length; i++) 
        {
            group.add(args[i]);
        }
        group.done();

(* было *)
do_job_with input filt group_by  consumer = input >>> filter filt >>> group group_by >> consumer


(* да, надо было параметризовать фильтрацию. ну ладно - рефакторим *)

do_job_with input filter group_by consumer = input >>> filter >>> group group_by >>> consumer

...

concrete_filter  = unique . filter filt 

...

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)  {...}

class UniqueFilter<T> implements IFilter<T> {
    private Collection<T> uniqueData = new HashSet();
    private IFilter<T> filter;
    UniqueFilter(IFilter<T> filter) {
       this.filter = filter;
    }
    
    boolean match(T t) {
       if (uniqueData.contains(t)) {
           return false;
       }
       if (filter.match(t)){ 
           uniqueData.add(t);
           return true;
       }
       return false;
    }
}

theData = ["abc", "def", "ijk", "axxx", "der", "preved", "%%%%%", "12345"]

type Discriminator a b = (a -> b)
type Group a b = (a, [b])
type GroupAction a b c = (Group a b -> c) 

groupByF :: Ord b => Discriminator a b -> [a] -> [Group b a]
groupByF discriminator list = 
    list >>== sortByF discriminator >>== groupByF discriminator >>== map (\list -> (discriminator $ head list, list))

filterByD :: (a -> Bool) -> [Group a b] -> [Group a b]
filterByD f = filter (\(groupId,_) -> f groupId)

writeConsole :: GroupAction String String (IO())                                              
writeConsole (groupId, []) = return ()
writeConsole (groupId, listOfWords) = putStrLn $ groupId ++ " -> " ++ (show listOfWords)

(>>==) :: a -> (a -> b) -> b
(>>==) x f = f x   

sortByF f = sortBy (\x y -> (f x) `compare` (f y))  
groupByF f = groupBy (\x y -> (f x) == (f y))  

main = theData 
       >>== groupByF (take 3) 
       >>== filterByD ((`elem` [x| x <- ['a'..'z']]).head)
       >>== mapM_ writeConsole

theData = ["abc", "def", "ijk", "axxx", "der", "preved", "%%%%%", "12345", "zoo"]

type Group = (String, [String])
type GroupAction a = (Group -> a) 

data Discriminator = DByPrefix String | DByContains String | DByPostfix String

match text (DByPrefix prefix) = isPrefixOf prefix text 
match text (DByContains prefix) = isInfixOf prefix text 
match text (DByPostfix prefix) = isSuffixOf prefix text 

groupId (DByPrefix prefix) = prefix 
groupId (DByContains prefix) = prefix 
groupId (DByPostfix prefix) = prefix 

groupByD :: [Discriminator] -> [String] -> [Group]
groupByD ds ws = (groupByD' ds ws) 
                 >>== sortByF fst >>== groupByF fst 
                 >>== map (\x -> (fst $ head x, map snd x)) 
    where 
        groupByD' ds [] = []  
        groupByD' ds (w:ws) = case find (match w) ds of
                                    Just x ->  (groupId x, w) : (groupByD' ds ws)
                                    Nothing ->groupByD' ds ws   
                
filterByD :: (String -> Bool) -> [Group] -> [Group]
filterByD f = filter (\(groupId,_) -> f groupId)

writeConsole :: GroupAction (IO())                                              
writeConsole (groupId, []) = return ()
writeConsole (groupId, listOfWords) = putStrLn $ groupId ++ " -> " ++ (show listOfWords)

(>>==) :: a -> (a -> b) -> b
(>>==) x f = f x   

sortByF f = sortBy (\x y -> (f x) `compare` (f y))  
groupByF f = groupBy (\x y -> (f x) == (f y))  

main = theData 
       >>== groupByD ((map DByPrefix [[x]| x <- ['a'..'n']]) ++ (map DByContains [[x]| x <- ['o'..'z']])) 
       >>== filterByD ((`elem` [x| x <- ['a'..'z']]).head) 
       >>== mapM_ writeConsole

theData = ["abc", "def", "ijk", "axxx", "der", "preved", "%%%%%", "12345", "zoo"]

--- IFilter and implementations?
data Discriminator = DByPrefix String | DByContains String | DByPostfix String

matchD text (DByPrefix prefix) = isPrefixOf prefix text 
matchD text (DByContains prefix) = isInfixOf prefix text 
matchD text (DByPostfix prefix) = isSuffixOf prefix text 

discrId (DByPrefix prefix) = prefix 
discrId (DByContains prefix) = prefix 
discrId (DByPostfix prefix) = prefix 

--- IProcessor and implementations ?
type GroupAction = (Group -> IO()) 

makeConsoleAction1 :: String -> GroupAction 
makeConsoleAction1 _ (_, []) = return ()
makeConsoleAction1 name (_, listOfWords) =  putStrLn $ name ++ " (prefix)-> " ++ (show listOfWords)

makeConsoleAction2 :: String -> GroupAction 
makeConsoleAction2 _ (_, []) = return ()
makeConsoleAction2 name (_, listOfWords) =  putStrLn $ name ++ " (contains)-> " ++ (show listOfWords)
  
writeConsole :: GroupAction                                              
writeConsole (_, []) = return ()
writeConsole (groupInfo, listOfWords) = putStrLn $ (groupId groupInfo) ++ " -> " ++ (show listOfWords)


--- IGroup and implementations ?
data GroupInfo = FilteredGroup GroupAction Discriminator

discriminator (FilteredGroup _ d) = d
action (FilteredGroup a _) = a
    
match text groupInfo = matchD text $ discriminator groupInfo 
groupId groupInfo = discrId $ discriminator groupInfo 

--- mutable (in oo) state of IGroup or IProcessor ... 
type Group = (GroupInfo, [String])

processGroup (groupInfo, listOfWords) = (action groupInfo) (groupInfo, listOfWords)

--- group builder...
groupByD :: [GroupInfo] -> [String] -> [Group]
groupByD ds ws = (groupByD' ds ws) 
                 >>== sortByF (groupId.fst) >>== groupByF (groupId.fst) 
                 >>== map (\x -> (fst $ head x, map snd x)) 
    where 
        groupByD' ds [] = []  
        groupByD' ds (w:ws) = case find (match w) ds of
                                    Just info -> (info, w) : (groupByD' ds ws)
                                    Nothing -> groupByD' ds ws   
                
filterByD :: (String -> Bool) -> [Group] -> [Group]
filterByD f = filter (\(groupInfo,_) -> f $ groupId groupInfo)

(>>==) :: a -> (a -> b) -> b
(>>==) x f = f x   

sortByF f = sortBy (\x y -> (f x) `compare` (f y))  
groupByF f = groupBy (\x y -> (f x) == (f y))  

--- solution itself
main = theData 
       >>== groupByD groupInfos  
       >>== filterByD ((`elem` [x| x <- ['a'..'z']]).head)  
       >>== mapM_ processGroup
    where        
       groupInfos = (map (\d -> FilteredGroup (makeConsoleAction1 (discrId d)) d) (map DByPrefix [[x]| x <- ['a'..'n']]))
                   ++ (map (\d -> FilteredGroup (makeConsoleAction2 (discrId d)) d) (map DByContains [[x]| x <- ['g'..'z']]))

void DoIt() {
  A++;
  B[C].D*=10;
  F(G).H=0;
}