Ocaml 带条件打印

我在这个问题中把问题讲清楚了。 我有一个这样的图表：

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

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

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

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.

我提取了一个列表

定义的

和

未定义的

，结果如下：

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

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

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

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 ordered = [["u"];["h"]; ["k"]; ["g"]; ["f"]; ["e"]; ["b"; "a"]]

我想写一个函数，在这样的条件下打印

有序的

的输出：

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

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

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

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.

1） 我想要一个函数，该函数将在列表中生成一个新的列表

ordered

，如果

undefined

中的元素出现，它将删除它。我期待着像这样的

newordered

：

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

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

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

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.

2） 我想在以下条件下打印他们的文件：

当它只是一种类型时，它将打印：

Definition name := type depend.

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

当它是等效（a b）时，它将打印：

Definition name := type depend.

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

当它是一个类型列表时，它将打印：

Inductive name := type depend.

Definition name := name. 

当它在

undefined

列表中看到类型时，当它没有depend type时，它将打印：

Inductive name := type depend.

Definition name := name. 

以及

newordered

列表中的顺序

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

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

我期望的输出如下所示：

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

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

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

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)

我有另一个函数，可以删除带有

未定义

列表的

有序

列表中的副本

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

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

让rec uniquify=函数
| [] -> []
|x:：xs->x:：uniquify（List.filter（（）x）xs）
让new_sort=uniquify（未定义@List.flant ordered）

但是这个列表是

字符串列表

，它在字体中添加了

未定义的

列表。因此，如果我先打印

undefined

中的所有元素，那么如果我打印最后一个函数，它将复制

undefined

。我不想那样

---

我不知道如何编写最后一个函数，并在最后打印我想要的输出。

首先，我通过查找

条目来更正
函数的
defn\u以返回标签关系的字符串表示：

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

其次，您在
new\u sort
中返回的内容（应该是
newordered
）显然是错误的。您真正想要的是过滤掉所有列表，其中一个元素出现在
未定义的
：

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

作为旁注，我选择将空列表作为
newordered
的一个元素来处理，尽管它没有出现在您的测试用例中。另一件事是
entries
被多次遍历以查找元素，应该将其更改为
Map
数据类型，尤其是当
entries
较大时

鉴于我已清楚说明了每种情况的条件，您应该能够将这些功能插入到您的程序中。
谢谢您的帮助！老实说，我正在努力证明这个函数是不是一个等价类。你在努力使用
newordered
还是创建
newordered
？因为
newordered
中同一列表中的两个标签是等价类。两者都是！上面的函数“new_sort”是我为“newordered”编写的，但我不希望它在这个新列表中添加未定义列表的类型。我只知道当它在等价类中时调用，但是当它有1个元素时呢？我的意思是当它有1个元素时，当它是一个等价类时，check可以调用的条件。这是我调用的函数，let print=List.iter（fun eqvclass->print\u defined\u eqvclass）new\u sorty您的
new\u sort
是错误的。我已经更新了我的答案以更正它。您现在可以在
new\u sort
上打印了。