|
44 | 44 |
|
45 | 45 | \print { |
46 | 46 | /* Continue evaluation. */ |
47 | | - ++this.wait; |
| 47 | + ++this.total; |
48 | 48 | } \wait[\print, \call]; |
49 | 49 |
|
50 | 50 | \eval[\fan_{i}(a, b)] { |
51 | 51 | /* Postpone evaluation. */ |
52 | | - ++this.wait; |
| 52 | + ++this.total; |
53 | 53 | } \fan_{i}[a, b]; |
54 | 54 |
|
55 | 55 | \eval[a] { |
56 | 56 | /* Continue evaluation. */ |
57 | | - ++this.wait; |
| 57 | + ++this.total; |
58 | 58 | } \wait[\eval(a), \call]; |
59 | 59 |
|
60 | 60 | \eval[\atom_{M}] { |
61 | 61 | /* Return an atom. */ |
62 | | - ++this.wait; |
| 62 | + ++this.total; |
63 | 63 | } \atom_{M}; |
64 | 64 |
|
65 | 65 | \eval[\lambda(a, b)] { |
66 | 66 | /* Return abstraction. */ |
67 | | - ++this.wait; |
| 67 | + ++this.total; |
68 | 68 | } \lambda[a, b]; |
69 | 69 |
|
70 | 70 | \read_{C}[\fan_{i}(a, b)] { |
71 | 71 | /* Duplicate context. */ |
72 | | - ++this.read; |
| 72 | + ++this.total; |
73 | 73 | } \fan_{i}[\read_{C}(a), \read_{this.clone(C)}(b)]; |
74 | 74 |
|
75 | 75 | \call { |
76 | 76 | /* Erase late call. */ |
77 | | - ++this.wait; |
| 77 | + ++this.total; |
78 | 78 | } \erase; |
79 | 79 |
|
80 | 80 | \fan_{i}[\wait(a, \amb(b, \decide(c, d), d)), \wait(e, b)] { |
81 | 81 | /* Postpone duplication. */ |
82 | | - ++this.wait; |
| 82 | + ++this.total; |
83 | 83 | } \wait[\fan_{i}(a, e), c]; |
84 | 84 |
|
85 | 85 | \call { |
86 | 86 | /* Continue evaluation. */ |
87 | | - ++this.wait; |
| 87 | + ++this.total; |
88 | 88 | } \decide[\call, \erase]; |
89 | 89 |
|
90 | 90 | \erase { |
91 | 91 | /* Erase reference. */ |
92 | | - ++this.wait; |
| 92 | + ++this.total; |
93 | 93 | } \decide[a, a]; |
94 | 94 |
|
95 | 95 | \call { |
96 | 96 | /* Continue evaluation. */ |
97 | | - ++this.wait; |
| 97 | + ++this.total; |
98 | 98 | } \hold[a, \eval(a)]; |
99 | 99 |
|
100 | 100 | \read_{C}[\wait(a, b)] { |
101 | 101 | /* Postpone readback. */ |
102 | | - ++this.wait; |
| 102 | + ++this.total; |
103 | 103 | } \wait[\read_{C}(a), b]; |
104 | 104 |
|
105 | 105 | \erase { |
106 | 106 | /* Erase holder. */ |
107 | | - ++this.wait; |
| 107 | + ++this.total; |
108 | 108 | } \hold[\erase, \erase]; |
109 | 109 |
|
110 | 110 | \erase { |
111 | 111 | /* Erase reference. */ |
112 | | - ++this.wait; |
| 112 | + ++this.total; |
113 | 113 | } \wait[\erase, \erase]; |
114 | 114 |
|
115 | 115 | \apply[a, \wait(b, \hold(\apply(a, b), \wait(c, d)))] { |
116 | 116 | /* Postpone application. */ |
117 | | - ++this.wait; |
| 117 | + ++this.total; |
118 | 118 | } \wait[c, d]; |
119 | 119 |
|
120 | 120 | \print { |
121 | 121 | /* Output results of read-back. */ |
122 | 122 | this.nf = M; |
123 | | - ++this.read; |
| 123 | + ++this.total; |
124 | 124 | } \atom_{M}; |
125 | 125 |
|
126 | 126 | \read_{C}[a] { |
127 | 127 | /* Read back abstraction. */ |
128 | | - ++this.read; |
| 128 | + ++this.total; |
129 | 129 | } \lambda[\atom_{this.mkid()}, \read_{this.abst(C)}(a)]; |
130 | 130 |
|
131 | 131 | \apply[\read_{this.appl(M)}(a), a] { |
132 | 132 | /* Read back application. */ |
133 | | - ++this.read; |
| 133 | + ++this.total; |
134 | 134 | } \atom_{M}; |
135 | 135 |
|
136 | 136 | \read_{C}[\atom_{this.atom(C, M)}] { |
137 | 137 | /* Read back an atom. */ |
138 | | - ++this.read; |
| 138 | + ++this.total; |
139 | 139 | } \atom_{M}; |
140 | 140 |
|
141 | 141 | \fan_{i}[\atom_{M}, \atom_{M}] { |
142 | 142 | /* Duplicate an atom. */ |
143 | | - ++this.read; |
| 143 | + ++this.total; |
144 | 144 | } \atom_{M}; |
145 | 145 |
|
146 | 146 | \erase { |
147 | 147 | /* Erase an atom. */ |
148 | | - ++this.read; |
| 148 | + ++this.total; |
149 | 149 | } \atom_{M}; |
150 | 150 |
|
151 | 151 | \erase { |
|
170 | 170 |
|
171 | 171 | \erase { |
172 | 172 | /* Erase context. */ |
173 | | - ++this.read; |
| 173 | + ++this.total; |
174 | 174 | } \read_{C}[\erase]; |
175 | 175 |
|
176 | 176 | $$ |
@@ -235,5 +235,3 @@ this.minus = cons.bind(this, "-"); |
235 | 235 | this.uniq = uniq; |
236 | 236 | this.beta = 0; |
237 | 237 | this.total = 0; |
238 | | -this.wait = 0; |
239 | | -this.read = 0; |
0 commit comments