D>>Да-да, вот тут и рушит Представь, что fun это flip и вспомни что вычисления идут лениво слева направо...

myComb = fun (_,1) _

myComb x y

fun (a,b) c = c a

myComb x y ~> 
(fun (_,1) _)  x y ~>
(_ _) x y ~>
x y
 -- ой мама биндеры переставились, должно-то быть y x

D>flip map [1,2,3]
D>

(`map` [1,2,3])

Животные
  рыбы
    щука
    карась
  птицы
    перепел
Растения
  ...

data Tree = Leaf Int String | Tree Int String [Tree]

Животные
    карась
  птицы
    перепел
Растения
  ...

T>Просмотрел. Но я нашёл поинтересней.

T>Оба-на!

+h Size
Sets the default heap size of processes to the size Size.

T>data Tree = Leaf Int String | Tree Int String [Tree]
T>

data Tree = Tree Int String [Tree]

task1 =  zip [1..]  -- нумеруем строки
     >>> makeTrees  -- формируем список деревьев

makeTrees =  groupFrom (not.isSpace.head.snd)  -- разбиваем на группы, начинающиеся со строки без отступа
                 -- в каждой из групп первую строчку используем для заголовка дерева
         >>> map ( \((linenum,string):xs) -> Tree linenum string  
                                                  -- а в оставшихся строках отрезаем первые два пробела и 
                                                  -- рекурсивно изготовляем из них список деревьев
                                                  (makeTrees (map (drop 2) xs)))

T>Животные
T>    карась
T>  птицы
T>    перепел
T>Растения
T>  ...
T>

groupFrom crit [] = []
groupFrom crit (x:xs) | not (crit x) = error "ах вы суки эдакие!!!"
groupFrom crit (x:xs) = let (l1:l2) = break crit xs
                        in (x:l1) : groupFrom crit l2

print (Tree linenum string subtrees) = string : map ("  "++) (concatMap print subtrees)

-- составление списка строк в дереве
strings (Tree _ string subtrees) = string : concatMap strings subtrees

-- получение дубликатов из списка строк
dups = sort >>> group >>> filter (not.null.tail) >>> map head

-- Оставить только часть дерева, содержащую строки из списка strList
onlyFrom strList (Tree linenum string subtrees) = 
  case (string `elem` strList, mapCatMaybes onlyDups subtrees) of
    (False, []) -> Nothing
    (_,     xs) -> Just (Tree linenum string xs)

task4 tree = onlyFrom (dups (strings tree)) tree

BZ>groupFrom crit [] = []
BZ>groupFrom crit (x:xs) | not (crit x) = error "ах вы суки эдакие!!!"
BZ>groupFrom crit (x:xs) = let (l1:l2) = break crit xs
BZ>                        in (x:l1) : groupFrom crit l2
BZ>

groupFrom crit [] = []
groupFrom crit (x:xs) = 
  let 
    (l1:l2) = break crit xs
    grp x l | not (crit x) = (fst x, "(!)") : x : l
    grp x l = x:l
  in grp x l1 : groupFrom crit l2

BZ>print (Tree linenum string subtrees) = string : map ("  "++) (concatMap print subtrees)
BZ>

Животные
  рыбы
    щука
    карась
    щука

Животные
  рыбы
    щука
    щука

Line = Struct.new(:string, :num, :level)
Leaf = Struct.new(:string, :num, :children)

def read_children(lines, level = 0)
    return [], [] if lines.empty?
    first, *rest = *lines
    case 
        when first.level == level
            children, rest = read_children(rest, level+1)
            first_child = Leaf[first.string, first.num, children]
            sibling, rest = read_children(rest, level)
            return [first_child] + sibling, rest
        when first.level < level
            return [], lines
        when first.level > level
            raise(RuntimeError, "wrong level at line #{first.num}")
    end
end

def print_tree(leafs, level = 0)
    leafs.each do |leaf|
        puts "   " * level + leaf.string
        print_tree(leaf.children, level + 1)
    end
end

def select_duplicates(leafs)
    dup_strings = leafs.
        map{|leaf| leaf.string}.
        group_by{|str| str}.
        select{|str, group| group.size > 1}.
        map{|str, group| str}

    leafs.
        map{|leaf| Leaf[leaf.string, leaf.num, select_duplicates(leaf.children)]}.
        select{|leaf| dup_strings.include?(leaf.string) || !leaf.children.empty?}
end

lines = File.read('tree.txt').split("\n").
    to_enum(:each_with_index).
    map{|ln, idx| Line[ln.strip, idx, ln[/^\s*/].length/2]}

roots, * = read_children(lines)
print_tree(roots)
dups = select_duplicates(roots)
print_tree(dups)

B>-- универсальная функция, группирует список пар (ключ, значение) по ключу, возвращая список пар (ключ, [значения для этого ключа])
B>-- например groupByFst [(1,2), (1,3), (2,5), (1,4), (2,6)] возвращает [ (1,[2,3,4]), (2,[5,6]) ]
B>-- записываем слово в файл "?.txt" если слово содержит букву ?
B>-- дополнительно слова, длиной 3 пишем во временный файл
B>-- дополнительно слова, начинающиеся с гласной буквы пишем в консоль
NGGU> type Targets = String -> [Target]
NGGU> targets3 :: Targets
B>targets3 word = byContain word ++ byLen3 word ++ byVowel word
B>  where
B>    byContain letters = [File $ s:".txt" | s <- letters]
B>    byLen3 letters | length letters == 3 = [TempFile]
B>                   | otherwise = []
B>    byVowel letters | head letters `elem` ['e','u','i','o','a'] = [Console]
B>                    | otherwise = []
B>

StartWith "a" -> WriteToFile "a"
StartWith "b" -> WriteToFile "b"
...
StartWith "z" -> WriteToFile "z"
Сontains "c" -> WriteToFile "Contains 'c | d'"
Сontains "d" -> WriteToFile "Contains 'c | d'"
StartWith "aaa" -> WriteToFile "aaa"
... 
StartWith "paa" -> WriteToConsole "test", WriteToFile "paa"
StartWith "pab" -> WriteToFile "aaa"
...
StartWith "zzz" -> WriteToFile "zzz"

StartWith x -> WriteToFile x, x in ["a" .. "z"] 

Сontains "c" | Сontains "d" -> WriteToFile "Contains 'c | d'"

Match (wordPrefix 3) | "paa"  -> WriteToConsole "debug", WriteToFile "paa"  
                     | prefix -> WriteToFile prefix

StartWith x -> WriteToFile x {unique: true}, x in ["a" .. "z"] 
-- ^^ в файл пишутся только уникальные строки (дубликаты игнорируются и в другие группы не попадают)
 
Сontains "c" | Сontains "d" {unique: true} -> WriteToFile "Contains 'c | d'"  
-- ^^ матчатся только уникальные строки (дубликаты не матчатся и могут попасть в другие группы)

Match (wordPrefix 3) | "paa"  -> WriteToConsole "debug", WriteToFile "paa"  
                     | prefix -> WriteToFile prefix

b = new RuleBuilder()
for(String x : new Range("a", "z")) {
    b.addRule(new StartWith(x), 
              new WriteToFile(x).unique(true));
}

b.addRule(new Or(new Contains("c"), new Contains("d")).unique(true), 
          new WriteToFile("Contains 'c | d'"));

b.addRule(new WordPrefixRule(3) {
              Action createDefaultAction(String prefix) { 
                     return new WriteToFile(prefix); 
              }
          }.add("paa", new WriteToConsole("debug"), new WriteToFile("paa")));

b.process(theData);

;;;; -*- Mode: Lisp; Syntax: Common-Lisp; Package: fp-train-1 -*-

(defpackage #:fp-train-1 (:use :cl))

(in-package #:fp-train-1)

(defun 1-st-letter (word)
   (cond ((symbolp word) (char (symbol-name word) 0))
    ((stringp word) (char word 0))
    ((characterp word) word)
    (t word)))

(let ((files nil))
   (defun letter-file (letter)
     (let ((file (cdr (assoc letter files))))
       (if file
      file
      (let ((file (open (string letter) :direction :output)))
        (setf files (acons letter file files))
        file))))
   (defun finish ()
     (mapc (lambda (e) (close (cdr e))) files)))

(defun cast-words (word-list)
   "Casts all words in WORD-LIST by files named A, B, ... Z according to their 
first letter"
   (unwind-protect
        (mapc
    (lambda (word)
      (format (letter-file (1-st-letter word)) "~A~%" word))
    word-list)
     (finish)))