-
Notifications
You must be signed in to change notification settings - Fork 1
/
SimFlush.mli
201 lines (186 loc) · 6.88 KB
/
SimFlush.mli
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
(*
module ImportSimulate :
sig
val newline : CamomileLibrary.UChar.t
val stringToList :
ReadPattern.ustring -> (Common.strIndex * ReadPattern.uchar) list
val compareHistory :
Common.tagOP array -> History.history -> History.history -> int
val interpretGroups :
Common.strIndex ->
CorePattern.groupInfo array -> 'o History.historyP -> Common.groupCap
val doTagTask :
Common.strIndex ->
'o History.historyP -> Common.tag * Common.tagTask -> unit
val doOrbitTask :
Common.strIndex ->
History.history -> Common.tag * Common.orbit * Common.orbitTask -> unit
val doRepTask : 'o History.historyP -> int * Common.repTask -> unit
val doTasks :
Common.strIndex -> History.history -> Common.taskList -> History.history
end
*)
(*
module RepStateID :
sig
type t = int array
val t_of_sexp__ : Sexplib.Sexp.t -> int array
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type sexpable = t
val compare : 'a -> 'a -> int
end
module BundleMap :
sig
module Key :
sig
type t = RepStateID.t
val sexp_of_t : t -> Sexplib.Sexp.t
val t_of_sexp : Sexplib.Sexp.t -> t
val compare : t -> t -> int
type comparator = Core.Core_map.Make(RepStateID).Key.comparator
val comparator : (t, comparator) Core.Comparator.t_
end
type 'v t = (Key.t, 'v, Key.comparator) Core.Core_map.t
val sexp_of_t : ('v -> Sexplib.Sexp.t) -> 'v t -> Sexplib.Sexp.t
val t_of_sexp : (Sexplib.Sexp.t -> 'v) -> Sexplib.Sexp.t -> 'v t
type ('k, 'v, 'comparator) t_ = 'v t
type 'a key_ = Key.t
type ('a, 'b, 'c) create_options =
('a, 'b, 'c) Core.Core_map_intf.create_options_without_comparator
val empty : ('k, 'comparator, ('k, 'a, 'comparator) t_) create_options
val singleton :
('k, 'comparator, 'k key_ -> 'v -> ('k, 'v, 'comparator) t_)
create_options
val of_alist :
('k, 'comparator,
('k key_ * 'v) list ->
[ `Duplicate_key of 'k key_ | `Ok of ('k, 'v, 'comparator) t_ ])
create_options
val of_alist_exn :
('k, 'comparator, ('k key_ * 'v) list -> ('k, 'v, 'comparator) t_)
create_options
val of_alist_multi :
('k, 'comparator, ('k key_ * 'v) list -> ('k, 'v list, 'comparator) t_)
create_options
val of_alist_fold :
('k, 'comparator,
('k key_ * 'v1) list ->
init:'v2 -> f:('v2 -> 'v1 -> 'v2) -> ('k, 'v2, 'comparator) t_)
create_options
val of_tree :
('k, 'comparator,
('k key_, 'v, 'comparator) Core.Core_map.tree ->
('k, 'v, 'comparator) t_)
create_options
val is_empty : ('a, 'b, 'c) t_ -> bool
val length : ('a, 'b, 'c) t_ -> int
val add :
('k, 'v, 'comparator) t_ ->
key:'k key_ -> data:'v -> ('k, 'v, 'comparator) t_
val add_multi :
('k, 'v list, 'comparator) t_ ->
key:'k key_ -> data:'v -> ('k, 'v list, 'comparator) t_
val change :
('k, 'v, 'comparator) t_ ->
'k key_ -> ('v option -> 'v option) -> ('k, 'v, 'comparator) t_
val find : ('k, 'v, 'a) t_ -> 'k key_ -> 'v option
val find_exn : ('k, 'v, 'a) t_ -> 'k key_ -> 'v
val remove :
('k, 'v, 'comparator) t_ -> 'k key_ -> ('k, 'v, 'comparator) t_
val mem : ('k, 'a, 'b) t_ -> 'k key_ -> bool
val iter : ('k, 'v, 'a) t_ -> f:(key:'k key_ -> data:'v -> unit) -> unit
val map :
('k, 'v1, 'comparator) t_ ->
f:('v1 -> 'v2) -> ('k, 'v2, 'comparator) t_
val mapi :
('k, 'v1, 'comparator) t_ ->
f:(key:'k key_ -> data:'v1 -> 'v2) -> ('k, 'v2, 'comparator) t_
val fold :
('k, 'v, 'b) t_ ->
init:'a -> f:(key:'k key_ -> data:'v -> 'a -> 'a) -> 'a
val fold_right :
('k, 'v, 'b) t_ ->
init:'a -> f:(key:'k key_ -> data:'v -> 'a -> 'a) -> 'a
val filter :
('k, 'v, 'comparator) t_ ->
f:(key:'k key_ -> data:'v -> bool) -> ('k, 'v, 'comparator) t_
val filter_map :
('k, 'v1, 'comparator) t_ ->
f:('v1 -> 'v2 option) -> ('k, 'v2, 'comparator) t_
val filter_mapi :
('k, 'v1, 'comparator) t_ ->
f:(key:'k key_ -> data:'v1 -> 'v2 option) -> ('k, 'v2, 'comparator) t_
val compare :
('v -> 'v -> int) ->
('k, 'v, 'comparator) t_ -> ('k, 'v, 'comparator) t_ -> int
val equal :
('v -> 'v -> bool) ->
('k, 'v, 'comparator) t_ -> ('k, 'v, 'comparator) t_ -> bool
val keys : ('k, 'a, 'b) t_ -> 'k key_ list
val data : ('a, 'v, 'b) t_ -> 'v list
val to_alist : ('k, 'v, 'a) t_ -> ('k key_ * 'v) list
val merge :
('k, 'v1, 'comparator) t_ ->
('k, 'v2, 'comparator) t_ ->
f:(key:'k key_ ->
[ `Both of 'v1 * 'v2 | `Left of 'v1 | `Right of 'v2 ] -> 'v3 option) ->
('k, 'v3, 'comparator) t_
val min_elt : ('k, 'v, 'a) t_ -> ('k key_ * 'v) option
val min_elt_exn : ('k, 'v, 'a) t_ -> 'k key_ * 'v
val max_elt : ('k, 'v, 'a) t_ -> ('k key_ * 'v) option
val max_elt_exn : ('k, 'v, 'a) t_ -> 'k key_ * 'v
val for_all : ('k, 'v, 'a) t_ -> f:('v -> bool) -> bool
val exists : ('k, 'v, 'a) t_ -> f:('v -> bool) -> bool
val fold_range_inclusive :
('k, 'v, 'b) t_ ->
min:'k key_ ->
max:'k key_ -> init:'a -> f:(key:'k key_ -> data:'v -> 'a -> 'a) -> 'a
val range_to_alist :
('k, 'v, 'a) t_ -> min:'k key_ -> max:'k key_ -> ('k key_ * 'v) list
val prev_key : ('k, 'v, 'a) t_ -> 'k key_ -> ('k key_ * 'v) option
val next_key : ('k, 'v, 'a) t_ -> 'k key_ -> ('k key_ * 'v) option
val rank : ('k, 'a, 'b) t_ -> 'k key_ -> int option
val to_tree :
('k, 'v, 'comparator) t_ ->
('k key_, 'v, 'comparator) Core.Core_map.tree
end
type bundle = History.history BundleMap.t
val bzero : ('a, 'b, ('a, 'c, 'b) BundleMap.t_) BundleMap.create_options
val forBundle : bundle -> (History.history -> unit) -> unit
val copyBundle :
('a, 'b History.historyP, 'c) BundleMap.t_ ->
('d, 'b History.historyP, 'e) BundleMap.t_
*)
(*
type 'b runPatternB =
ROneChar of CorePattern.uset * 'b ref
| RTest
| RSeq of 'b runQB * 'b ref * 'b runQB
| ROr of 'b runQB list
| RCaptureGroup of CorePattern.capGroupQ * 'b runQB
| RRepeat of CorePattern.repeatQ * 'b ref * 'b runQB
and 'b runQB = {
getCore : CorePattern.coreQ;
getRun : 'b runPatternB;
mutable numHistories : int;
}
type runPattern = bundle runPatternB
type runQ = bundle runQB
val coreToRun : CorePattern.coreQ -> runQ
*)
module ImportSimStep :
sig
type stepData =
StepChar of (Common.strIndex * ReadPattern.uchar)
| StepEnd of Common.strIndex
type simFeed = stepData -> History.history list
type o = (Common.groupCap * History.history) list
end
val simFlush :
?prevIn:Common.strIndex * ReadPattern.uchar ->
CorePattern.coreResult -> ImportSimStep.simFeed
val uWrapFlush :
CorePattern.coreResult -> ReadPattern.ustring -> ImportSimStep.o
val wrapSimFlush :
ReadPattern.ustring -> ReadPattern.ustring -> ImportSimStep.o