@grain/stdlib 0.5.12 → 0.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (155) hide show
  1. package/CHANGELOG.md +200 -0
  2. package/LICENSE +1 -1
  3. package/README.md +25 -2
  4. package/array.gr +1512 -199
  5. package/array.md +2032 -94
  6. package/bigint.gr +239 -140
  7. package/bigint.md +450 -106
  8. package/buffer.gr +595 -102
  9. package/buffer.md +903 -145
  10. package/bytes.gr +401 -110
  11. package/bytes.md +551 -63
  12. package/char.gr +228 -49
  13. package/char.md +373 -7
  14. package/exception.gr +26 -12
  15. package/exception.md +29 -5
  16. package/float32.gr +130 -109
  17. package/float32.md +185 -57
  18. package/float64.gr +112 -99
  19. package/float64.md +185 -57
  20. package/hash.gr +47 -37
  21. package/hash.md +21 -3
  22. package/int16.gr +430 -0
  23. package/int16.md +618 -0
  24. package/int32.gr +200 -269
  25. package/int32.md +254 -289
  26. package/int64.gr +142 -225
  27. package/int64.md +254 -289
  28. package/int8.gr +511 -0
  29. package/int8.md +786 -0
  30. package/json.gr +2084 -0
  31. package/json.md +608 -0
  32. package/list.gr +120 -68
  33. package/list.md +125 -80
  34. package/map.gr +560 -57
  35. package/map.md +672 -56
  36. package/marshal.gr +239 -227
  37. package/marshal.md +36 -4
  38. package/number.gr +626 -676
  39. package/number.md +738 -153
  40. package/option.gr +33 -35
  41. package/option.md +58 -42
  42. package/package.json +2 -2
  43. package/path.gr +148 -187
  44. package/path.md +47 -96
  45. package/pervasives.gr +75 -416
  46. package/pervasives.md +85 -180
  47. package/priorityqueue.gr +433 -74
  48. package/priorityqueue.md +422 -54
  49. package/queue.gr +362 -80
  50. package/queue.md +433 -38
  51. package/random.gr +67 -75
  52. package/random.md +68 -40
  53. package/range.gr +135 -63
  54. package/range.md +198 -43
  55. package/rational.gr +284 -0
  56. package/rational.md +545 -0
  57. package/regex.gr +933 -1066
  58. package/regex.md +59 -60
  59. package/result.gr +23 -25
  60. package/result.md +54 -39
  61. package/runtime/atof/common.gr +78 -82
  62. package/runtime/atof/common.md +22 -10
  63. package/runtime/atof/decimal.gr +102 -127
  64. package/runtime/atof/decimal.md +28 -7
  65. package/runtime/atof/lemire.gr +56 -71
  66. package/runtime/atof/lemire.md +9 -1
  67. package/runtime/atof/parse.gr +83 -110
  68. package/runtime/atof/parse.md +12 -2
  69. package/runtime/atof/slow.gr +28 -35
  70. package/runtime/atof/slow.md +9 -1
  71. package/runtime/atof/table.gr +19 -18
  72. package/runtime/atof/table.md +10 -2
  73. package/runtime/atoi/parse.gr +153 -136
  74. package/runtime/atoi/parse.md +50 -1
  75. package/runtime/bigint.gr +410 -517
  76. package/runtime/bigint.md +71 -57
  77. package/runtime/compare.gr +176 -85
  78. package/runtime/compare.md +31 -1
  79. package/runtime/dataStructures.gr +144 -32
  80. package/runtime/dataStructures.md +267 -31
  81. package/runtime/debugPrint.gr +34 -15
  82. package/runtime/debugPrint.md +37 -5
  83. package/runtime/equal.gr +53 -52
  84. package/runtime/equal.md +30 -1
  85. package/runtime/exception.gr +38 -47
  86. package/runtime/exception.md +10 -8
  87. package/runtime/gc.gr +23 -152
  88. package/runtime/gc.md +13 -17
  89. package/runtime/malloc.gr +31 -31
  90. package/runtime/malloc.md +11 -3
  91. package/runtime/numberUtils.gr +191 -172
  92. package/runtime/numberUtils.md +17 -9
  93. package/runtime/numbers.gr +1695 -1021
  94. package/runtime/numbers.md +1098 -134
  95. package/runtime/string.gr +540 -242
  96. package/runtime/string.md +76 -6
  97. package/runtime/unsafe/constants.gr +30 -13
  98. package/runtime/unsafe/constants.md +80 -0
  99. package/runtime/unsafe/conv.gr +55 -28
  100. package/runtime/unsafe/conv.md +41 -9
  101. package/runtime/unsafe/memory.gr +10 -30
  102. package/runtime/unsafe/memory.md +15 -19
  103. package/runtime/unsafe/tags.gr +37 -21
  104. package/runtime/unsafe/tags.md +88 -8
  105. package/runtime/unsafe/wasmf32.gr +30 -36
  106. package/runtime/unsafe/wasmf32.md +64 -56
  107. package/runtime/unsafe/wasmf64.gr +30 -36
  108. package/runtime/unsafe/wasmf64.md +64 -56
  109. package/runtime/unsafe/wasmi32.gr +49 -66
  110. package/runtime/unsafe/wasmi32.md +102 -94
  111. package/runtime/unsafe/wasmi64.gr +52 -79
  112. package/runtime/unsafe/wasmi64.md +108 -100
  113. package/runtime/utils/printing.gr +13 -15
  114. package/runtime/utils/printing.md +11 -3
  115. package/runtime/wasi.gr +294 -295
  116. package/runtime/wasi.md +62 -42
  117. package/set.gr +574 -64
  118. package/set.md +634 -54
  119. package/stack.gr +181 -64
  120. package/stack.md +271 -42
  121. package/string.gr +453 -533
  122. package/string.md +241 -151
  123. package/uint16.gr +369 -0
  124. package/uint16.md +585 -0
  125. package/uint32.gr +470 -0
  126. package/uint32.md +737 -0
  127. package/uint64.gr +471 -0
  128. package/uint64.md +737 -0
  129. package/uint8.gr +369 -0
  130. package/uint8.md +585 -0
  131. package/uri.gr +1093 -0
  132. package/uri.md +477 -0
  133. package/{sys → wasi}/file.gr +914 -500
  134. package/{sys → wasi}/file.md +454 -50
  135. package/wasi/process.gr +292 -0
  136. package/{sys → wasi}/process.md +164 -6
  137. package/wasi/random.gr +77 -0
  138. package/wasi/random.md +80 -0
  139. package/{sys → wasi}/time.gr +15 -22
  140. package/{sys → wasi}/time.md +5 -5
  141. package/immutablearray.gr +0 -929
  142. package/immutablearray.md +0 -1038
  143. package/immutablemap.gr +0 -493
  144. package/immutablemap.md +0 -479
  145. package/immutablepriorityqueue.gr +0 -360
  146. package/immutablepriorityqueue.md +0 -291
  147. package/immutableset.gr +0 -498
  148. package/immutableset.md +0 -449
  149. package/runtime/debug.gr +0 -2
  150. package/runtime/debug.md +0 -6
  151. package/runtime/unsafe/errors.gr +0 -36
  152. package/runtime/unsafe/errors.md +0 -204
  153. package/sys/process.gr +0 -254
  154. package/sys/random.gr +0 -79
  155. package/sys/random.md +0 -66
@@ -1,300 +1,308 @@
1
- ### Wasmi64.**load**
1
+ ---
2
+ title: WasmI64
3
+ ---
4
+
5
+ ## Values
6
+
7
+ Functions and constants included in the WasmI64 module.
8
+
9
+ ### WasmI64.**load**
2
10
 
3
11
  ```grain
4
- load : (WasmI32, WasmI32) -> WasmI64
12
+ load : (ptr: WasmI32, offset: WasmI32) => WasmI64
5
13
  ```
6
14
 
7
- ### Wasmi64.**load8S**
15
+ ### WasmI64.**load8S**
8
16
 
9
17
  ```grain
10
- load8S : (WasmI32, WasmI32) -> WasmI64
18
+ load8S : (ptr: WasmI32, offset: WasmI32) => WasmI64
11
19
  ```
12
20
 
13
- ### Wasmi64.**load8U**
21
+ ### WasmI64.**load8U**
14
22
 
15
23
  ```grain
16
- load8U : (WasmI32, WasmI32) -> WasmI64
24
+ load8U : (ptr: WasmI32, offset: WasmI32) => WasmI64
17
25
  ```
18
26
 
19
- ### Wasmi64.**load16S**
27
+ ### WasmI64.**load16S**
20
28
 
21
29
  ```grain
22
- load16S : (WasmI32, WasmI32) -> WasmI64
30
+ load16S : (ptr: WasmI32, offset: WasmI32) => WasmI64
23
31
  ```
24
32
 
25
- ### Wasmi64.**load16U**
33
+ ### WasmI64.**load16U**
26
34
 
27
35
  ```grain
28
- load16U : (WasmI32, WasmI32) -> WasmI64
36
+ load16U : (ptr: WasmI32, offset: WasmI32) => WasmI64
29
37
  ```
30
38
 
31
- ### Wasmi64.**load32S**
39
+ ### WasmI64.**load32S**
32
40
 
33
41
  ```grain
34
- load32S : (WasmI32, WasmI32) -> WasmI64
42
+ load32S : (ptr: WasmI32, offset: WasmI32) => WasmI64
35
43
  ```
36
44
 
37
- ### Wasmi64.**load32U**
45
+ ### WasmI64.**load32U**
38
46
 
39
47
  ```grain
40
- load32U : (WasmI32, WasmI32) -> WasmI64
48
+ load32U : (ptr: WasmI32, offset: WasmI32) => WasmI64
41
49
  ```
42
50
 
43
- ### Wasmi64.**store**
51
+ ### WasmI64.**store**
44
52
 
45
53
  ```grain
46
- store : (WasmI32, WasmI64, WasmI32) -> Void
54
+ store : (ptr: WasmI32, value: WasmI64, offset: WasmI32) => Void
47
55
  ```
48
56
 
49
- ### Wasmi64.**store8**
57
+ ### WasmI64.**store8**
50
58
 
51
59
  ```grain
52
- store8 : (WasmI32, WasmI64, WasmI32) -> Void
60
+ store8 : (ptr: WasmI32, value: WasmI64, offset: WasmI32) => Void
53
61
  ```
54
62
 
55
- ### Wasmi64.**store16**
63
+ ### WasmI64.**store16**
56
64
 
57
65
  ```grain
58
- store16 : (WasmI32, WasmI64, WasmI32) -> Void
66
+ store16 : (ptr: WasmI32, value: WasmI64, offset: WasmI32) => Void
59
67
  ```
60
68
 
61
- ### Wasmi64.**store32**
69
+ ### WasmI64.**store32**
62
70
 
63
71
  ```grain
64
- store32 : (WasmI32, WasmI64, WasmI32) -> Void
72
+ store32 : (ptr: WasmI32, value: WasmI64, offset: WasmI32) => Void
65
73
  ```
66
74
 
67
- ### Wasmi64.**clz**
75
+ ### WasmI64.**clz**
68
76
 
69
77
  ```grain
70
- clz : WasmI64 -> WasmI64
78
+ clz : (num: WasmI64) => WasmI64
71
79
  ```
72
80
 
73
- ### Wasmi64.**ctz**
81
+ ### WasmI64.**ctz**
74
82
 
75
83
  ```grain
76
- ctz : WasmI64 -> WasmI64
84
+ ctz : (num: WasmI64) => WasmI64
77
85
  ```
78
86
 
79
- ### Wasmi64.**popcnt**
87
+ ### WasmI64.**popcnt**
80
88
 
81
89
  ```grain
82
- popcnt : WasmI64 -> WasmI64
90
+ popcnt : (num: WasmI64) => WasmI64
83
91
  ```
84
92
 
85
- ### Wasmi64.**eqz**
93
+ ### WasmI64.**eqz**
86
94
 
87
95
  ```grain
88
- eqz : WasmI64 -> Bool
96
+ eqz : (num: WasmI64) => Bool
89
97
  ```
90
98
 
91
- ### Wasmi64.**add**
99
+ ### WasmI64.**(+)**
92
100
 
93
101
  ```grain
94
- add : (WasmI64, WasmI64) -> WasmI64
102
+ (+) : (left: WasmI64, right: WasmI64) => WasmI64
95
103
  ```
96
104
 
97
- ### Wasmi64.**sub**
105
+ ### WasmI64.**(-)**
98
106
 
99
107
  ```grain
100
- sub : (WasmI64, WasmI64) -> WasmI64
108
+ (-) : (left: WasmI64, right: WasmI64) => WasmI64
101
109
  ```
102
110
 
103
- ### Wasmi64.**mul**
111
+ ### WasmI64.**(*)**
104
112
 
105
113
  ```grain
106
- mul : (WasmI64, WasmI64) -> WasmI64
114
+ (*) : (left: WasmI64, right: WasmI64) => WasmI64
107
115
  ```
108
116
 
109
- ### Wasmi64.**divS**
117
+ ### WasmI64.**(/)**
110
118
 
111
119
  ```grain
112
- divS : (WasmI64, WasmI64) -> WasmI64
120
+ (/) : (left: WasmI64, right: WasmI64) => WasmI64
113
121
  ```
114
122
 
115
- ### Wasmi64.**divU**
123
+ ### WasmI64.**divU**
116
124
 
117
125
  ```grain
118
- divU : (WasmI64, WasmI64) -> WasmI64
126
+ divU : (left: WasmI64, right: WasmI64) => WasmI64
119
127
  ```
120
128
 
121
- ### Wasmi64.**remS**
129
+ ### WasmI64.**remS**
122
130
 
123
131
  ```grain
124
- remS : (WasmI64, WasmI64) -> WasmI64
132
+ remS : (left: WasmI64, right: WasmI64) => WasmI64
125
133
  ```
126
134
 
127
- ### Wasmi64.**remU**
135
+ ### WasmI64.**remU**
128
136
 
129
137
  ```grain
130
- remU : (WasmI64, WasmI64) -> WasmI64
138
+ remU : (left: WasmI64, right: WasmI64) => WasmI64
131
139
  ```
132
140
 
133
- ### Wasmi64.**and**
141
+ ### WasmI64.**(&)**
134
142
 
135
143
  ```grain
136
- and : (WasmI64, WasmI64) -> WasmI64
144
+ (&) : (left: WasmI64, right: WasmI64) => WasmI64
137
145
  ```
138
146
 
139
- ### Wasmi64.**or**
147
+ ### WasmI64.**(|)**
140
148
 
141
149
  ```grain
142
- or : (WasmI64, WasmI64) -> WasmI64
150
+ (|) : (left: WasmI64, right: WasmI64) => WasmI64
143
151
  ```
144
152
 
145
- ### Wasmi64.**xor**
153
+ ### WasmI64.**(^)**
146
154
 
147
155
  ```grain
148
- xor : (WasmI64, WasmI64) -> WasmI64
156
+ (^) : (left: WasmI64, right: WasmI64) => WasmI64
149
157
  ```
150
158
 
151
- ### Wasmi64.**shl**
159
+ ### WasmI64.**(<<)**
152
160
 
153
161
  ```grain
154
- shl : (WasmI64, WasmI64) -> WasmI64
162
+ (<<) : (left: WasmI64, right: WasmI64) => WasmI64
155
163
  ```
156
164
 
157
- ### Wasmi64.**shrU**
165
+ ### WasmI64.**(>>>)**
158
166
 
159
167
  ```grain
160
- shrU : (WasmI64, WasmI64) -> WasmI64
168
+ (>>>) : (left: WasmI64, right: WasmI64) => WasmI64
161
169
  ```
162
170
 
163
- ### Wasmi64.**shrS**
171
+ ### WasmI64.**(>>)**
164
172
 
165
173
  ```grain
166
- shrS : (WasmI64, WasmI64) -> WasmI64
174
+ (>>) : (left: WasmI64, right: WasmI64) => WasmI64
167
175
  ```
168
176
 
169
- ### Wasmi64.**rotl**
177
+ ### WasmI64.**rotl**
170
178
 
171
179
  ```grain
172
- rotl : (WasmI64, WasmI64) -> WasmI64
180
+ rotl : (left: WasmI64, right: WasmI64) => WasmI64
173
181
  ```
174
182
 
175
- ### Wasmi64.**rotr**
183
+ ### WasmI64.**rotr**
176
184
 
177
185
  ```grain
178
- rotr : (WasmI64, WasmI64) -> WasmI64
186
+ rotr : (left: WasmI64, right: WasmI64) => WasmI64
179
187
  ```
180
188
 
181
- ### Wasmi64.**eq**
189
+ ### WasmI64.**(==)**
182
190
 
183
191
  ```grain
184
- eq : (WasmI64, WasmI64) -> Bool
192
+ (==) : (left: WasmI64, right: WasmI64) => Bool
185
193
  ```
186
194
 
187
- ### Wasmi64.**ne**
195
+ ### WasmI64.**(!=)**
188
196
 
189
197
  ```grain
190
- ne : (WasmI64, WasmI64) -> Bool
198
+ (!=) : (left: WasmI64, right: WasmI64) => Bool
191
199
  ```
192
200
 
193
- ### Wasmi64.**ltS**
201
+ ### WasmI64.**(<)**
194
202
 
195
203
  ```grain
196
- ltS : (WasmI64, WasmI64) -> Bool
204
+ (<) : (left: WasmI64, right: WasmI64) => Bool
197
205
  ```
198
206
 
199
- ### Wasmi64.**ltU**
207
+ ### WasmI64.**ltU**
200
208
 
201
209
  ```grain
202
- ltU : (WasmI64, WasmI64) -> Bool
210
+ ltU : (left: WasmI64, right: WasmI64) => Bool
203
211
  ```
204
212
 
205
- ### Wasmi64.**leS**
213
+ ### WasmI64.**(<=)**
206
214
 
207
215
  ```grain
208
- leS : (WasmI64, WasmI64) -> Bool
216
+ (<=) : (left: WasmI64, right: WasmI64) => Bool
209
217
  ```
210
218
 
211
- ### Wasmi64.**leU**
219
+ ### WasmI64.**leU**
212
220
 
213
221
  ```grain
214
- leU : (WasmI64, WasmI64) -> Bool
222
+ leU : (left: WasmI64, right: WasmI64) => Bool
215
223
  ```
216
224
 
217
- ### Wasmi64.**gtS**
225
+ ### WasmI64.**(>)**
218
226
 
219
227
  ```grain
220
- gtS : (WasmI64, WasmI64) -> Bool
228
+ (>) : (left: WasmI64, right: WasmI64) => Bool
221
229
  ```
222
230
 
223
- ### Wasmi64.**gtU**
231
+ ### WasmI64.**gtU**
224
232
 
225
233
  ```grain
226
- gtU : (WasmI64, WasmI64) -> Bool
234
+ gtU : (left: WasmI64, right: WasmI64) => Bool
227
235
  ```
228
236
 
229
- ### Wasmi64.**geS**
237
+ ### WasmI64.**(>=)**
230
238
 
231
239
  ```grain
232
- geS : (WasmI64, WasmI64) -> Bool
240
+ (>=) : (left: WasmI64, right: WasmI64) => Bool
233
241
  ```
234
242
 
235
- ### Wasmi64.**geU**
243
+ ### WasmI64.**geU**
236
244
 
237
245
  ```grain
238
- geU : (WasmI64, WasmI64) -> Bool
246
+ geU : (left: WasmI64, right: WasmI64) => Bool
239
247
  ```
240
248
 
241
- ### Wasmi64.**extendI32S**
249
+ ### WasmI64.**extendI32S**
242
250
 
243
251
  ```grain
244
- extendI32S : WasmI32 -> WasmI64
252
+ extendI32S : (num: WasmI32) => WasmI64
245
253
  ```
246
254
 
247
- ### Wasmi64.**extendI32U**
255
+ ### WasmI64.**extendI32U**
248
256
 
249
257
  ```grain
250
- extendI32U : WasmI32 -> WasmI64
258
+ extendI32U : (num: WasmI32) => WasmI64
251
259
  ```
252
260
 
253
- ### Wasmi64.**truncF32S**
261
+ ### WasmI64.**truncF32S**
254
262
 
255
263
  ```grain
256
- truncF32S : WasmF32 -> WasmI64
264
+ truncF32S : (num: WasmF32) => WasmI64
257
265
  ```
258
266
 
259
- ### Wasmi64.**truncF32U**
267
+ ### WasmI64.**truncF32U**
260
268
 
261
269
  ```grain
262
- truncF32U : WasmF32 -> WasmI64
270
+ truncF32U : (num: WasmF32) => WasmI64
263
271
  ```
264
272
 
265
- ### Wasmi64.**truncF64S**
273
+ ### WasmI64.**truncF64S**
266
274
 
267
275
  ```grain
268
- truncF64S : WasmF64 -> WasmI64
276
+ truncF64S : (num: WasmF64) => WasmI64
269
277
  ```
270
278
 
271
- ### Wasmi64.**truncF64U**
279
+ ### WasmI64.**truncF64U**
272
280
 
273
281
  ```grain
274
- truncF64U : WasmF64 -> WasmI64
282
+ truncF64U : (num: WasmF64) => WasmI64
275
283
  ```
276
284
 
277
- ### Wasmi64.**reinterpretF64**
285
+ ### WasmI64.**reinterpretF64**
278
286
 
279
287
  ```grain
280
- reinterpretF64 : WasmF64 -> WasmI64
288
+ reinterpretF64 : (num: WasmF64) => WasmI64
281
289
  ```
282
290
 
283
- ### Wasmi64.**extendS8**
291
+ ### WasmI64.**extendS8**
284
292
 
285
293
  ```grain
286
- extendS8 : WasmI64 -> WasmI64
294
+ extendS8 : (num: WasmI64) => WasmI64
287
295
  ```
288
296
 
289
- ### Wasmi64.**extendS16**
297
+ ### WasmI64.**extendS16**
290
298
 
291
299
  ```grain
292
- extendS16 : WasmI64 -> WasmI64
300
+ extendS16 : (num: WasmI64) => WasmI64
293
301
  ```
294
302
 
295
- ### Wasmi64.**extendS32**
303
+ ### WasmI64.**extendS32**
296
304
 
297
305
  ```grain
298
- extendS32 : WasmI64 -> WasmI64
306
+ extendS32 : (num: WasmI64) => WasmI64
299
307
  ```
300
308
 
@@ -1,25 +1,23 @@
1
- /* grainc-flags --no-pervasives */
1
+ @noPervasives
2
+ module Printing
3
+
2
4
  // Printing utilities for runtime code (primarily for debugging)
3
- import WasmI32 from "runtime/unsafe/wasmi32"
4
- import Memory from "runtime/unsafe/memory"
5
- import NumberUtils from "runtime/numberUtils"
5
+ from "runtime/unsafe/wasmi32" include WasmI32
6
+ from "runtime/unsafe/memory" include Memory
7
+ from "runtime/numberUtils" include NumberUtils
6
8
 
7
- import foreign wasm fd_write: (
8
- WasmI32,
9
- WasmI32,
10
- WasmI32,
11
- WasmI32,
12
- ) -> WasmI32 from "wasi_snapshot_preview1"
9
+ foreign wasm fd_write:
10
+ (WasmI32, WasmI32, WasmI32, WasmI32) => WasmI32 from "wasi_snapshot_preview1"
13
11
 
14
12
  @unsafe
15
- export let numberToString = (n: WasmI64) => {
13
+ provide let numberToString = (n: WasmI64) => {
16
14
  NumberUtils.itoa64(n, 10n)
17
15
  }
18
16
 
19
17
  @unsafe
20
- export let printNumber = (n: WasmI64) => {
18
+ provide let printNumber = (n: WasmI64) => {
21
19
  // like print(), but `s` should be a Grain string
22
- let (+) = WasmI32.add
20
+ use WasmI32.{ (+) }
23
21
  let s = numberToString(n)
24
22
  let ptr = WasmI32.fromGrain(s)
25
23
  // iov: [<ptr to string> <nbytes of string> <ptr to newline> <nbytes of newline>] (32 bytes)
@@ -40,9 +38,9 @@ export let printNumber = (n: WasmI64) => {
40
38
  }
41
39
 
42
40
  @unsafe
43
- export let printString = (s: String) => {
41
+ provide let printString = (s: String) => {
44
42
  // like print(), but `s` should be a Grain string
45
- let (+) = WasmI32.add
43
+ use WasmI32.{ (+) }
46
44
  let ptr = WasmI32.fromGrain(s)
47
45
  // iov: [<ptr to string> <nbytes of string> <ptr to newline> <nbytes of newline>] (32 bytes)
48
46
  // buf: <iov> <written> <newline char>
@@ -1,18 +1,26 @@
1
+ ---
2
+ title: Printing
3
+ ---
4
+
5
+ ## Values
6
+
7
+ Functions and constants included in the Printing module.
8
+
1
9
  ### Printing.**numberToString**
2
10
 
3
11
  ```grain
4
- numberToString : WasmI64 -> String
12
+ numberToString : (n: WasmI64) => String
5
13
  ```
6
14
 
7
15
  ### Printing.**printNumber**
8
16
 
9
17
  ```grain
10
- printNumber : WasmI64 -> Void
18
+ printNumber : (n: WasmI64) => Void
11
19
  ```
12
20
 
13
21
  ### Printing.**printString**
14
22
 
15
23
  ```grain
16
- printString : String -> Void
24
+ printString : (s: String) => Void
17
25
  ```
18
26