Печать с условиями

Question

Я четко задаю вопрос в этом вопросе. У меня есть такой график:

a <-> b -> e -> f
|          |
v          v
h <------- g 
|          |
v          v  
u          k  

В списке описываются зависимости entries

let entries = [
  ("a", ["b"; "h"]);
  ("b", ["a"; "e"]);
  ("e", ["f"; "g"]);
  ("g", ["h"; "k"]);
  ("h", ["u"]);
]

Я извлек список defined и undefined, результат выглядит так:

let defined = ["a"; "b"; "e"; "g"; "h"; "u"]
let undefined = ["f"; "k"]

После вычислений я получил новый список с их порядком:

let ordered = [["u"];["h"]; ["k"]; ["g"]; ["f"]; ["e"]; ["b"; "a"]]

Я хочу написать функцию, которая выводит вывод ordered в таких условиях, как это:

1) Я хочу иметь функцию, которая будет генерировать новый список в списке ordered, если элемент в undefined появится, он удалит его. Я ожидаю newordered вот так:

newordered = [["u"]; ["h"]; ["g"]; ["e"]; ["b"; "a"]]

2) Я хочу напечатать их в зависимости от следующих условий:

когда это только один тип зависимости, он напечатает:

Definition name := type depend.

когда это эквивалентность (a <-> b), будет напечатано:

Inductive name1 := type depend 1
with name2 := type depend 2.

когда список зависит от типа, он напечатает:

Inductive name := type depend.

Когда он увидит тип в списке undefined, и когда он не будет зависеть от типа, он напечатает:

Definition name := name. 

и при заказе в списке newordered

Вывод, который я ожидаю, выглядит так:

Definition k := k.
Definition f := f.
Definition u := u.
Definition h := u.
Inductive g := h -> k.
Inductive e := f -> g.
Inductive b := a -> e
with a := b -> h.

Я пишу эти функции, сначала я печатаю все элементы в неопределенном списке:

let print_undfined =
List.iter (fun name -> Printf.printf "\nDefinition %s := %s." name name;
      print_string "\n")undefined

У меня есть функция, которая печатает правую часть списка записей:

let defn_of =
  List.iter (fun (_, xs) -> 
    List.iter (fun t -> Printf.printf "%s" t) xs)

У меня есть еще одна функция, которая удаляет дубликаты в списке ordered с помощью списка undefined

let rec uniquify = function
| [] -> []
| x::xs -> x :: uniquify (List.filter ((<>) x) xs)

let new_sort = uniquify (undefined @ List.flatten ordered)

Но этот список string list, и он добавил список undefined в шрифт. Поэтому, если я напечатаю последнюю функцию, она будет дублировать undefined, если я решу сначала напечатать все элементы в undefined. И я не хочу этого.

И я не понимаю, как мне написать последнюю функцию с выводом для меня нужного результата в конце.

Answer 1

Во-первых, я исправляю функцию defn_of, чтобы она возвращала строковое представление отношений метки путем поиска entries:

let defn_of label =
    try
       let (_, xs) = List.find (fun (l, ys) -> l = label) entries in
       String.concat "->" xs
    with
        Not_found -> ""

Во-вторых, что вы вернули в new_sort (что должно бытьnewordered) явно неправильно.Что вам действительно нужно, так это отфильтровывать все списки с помощью одного элемента, встречающегося в undefined:

let newordered = List.filter (function [x] -> List.for_all((<>) x) undefined
                                       | _ -> true) ordered

Как обычно, функции печати основаны на функциях в модулях Printf и String.concat.В задании на печать есть два случая:

Случай 1: для всех этикеток в undefined, используйте функцию print_undfined выше.

Случай2: для любого списка xs в newordered, если xs имеет только один элемент, это означает, что класс эквивалентности не существует.Если xs имеет хотя бы два элемента, классы эквивалентности должны быть напечатаны:

let print_defined_equivalence xs = 
    match xs with
    | [] -> ()
    | [x] -> Printf.printf "\nInductive %s := %s." x (defn_of x)
    | _ ->
        let ys = String.concat "\nwith" 
                  (List.map (fun x -> 
                     Printf.sprintf "%s := %s" x (defn_of x)) 
                        xs) in
        Printf.printf "\nInductive %s." ys

В качестве примечания, я решил обрабатывать пустой список как элемент newordered, хотя этого не произошло вваш тестовый случай.Другое дело, что entries многократно просматривается для поиска элементов, его следует изменить на Map тип данных, особенно когда entries большой.

Учитывая тот факт, что я четко указал условие дляв каждом случае вы должны иметь возможность подключить эти функции к вашей программе.