add ignore for every stdlib type t

lib/es6/Stdlib.js

@@ -1,6 +1,7 @@
 
 
 import * as Stdlib_Error from "./Stdlib_Error.js";
+import * as Stdlib_Global from "./Stdlib_Global.js";
 import * as Primitive_object from "./Primitive_object.js";
 
 function assertEqual(a, b) {
@@ -18,6 +19,10 @@ function assertEqual(a, b) {
   };
 }
 
+let TimeoutId = Stdlib_Global.TimeoutId;
+
+let IntervalId = Stdlib_Global.IntervalId;
+
 let $$Array;
 
 let $$BigInt;
@@ -109,6 +114,8 @@ let $$BigUint64Array;
 let panic = Stdlib_Error.panic;
 
 export {
+  TimeoutId,
+  IntervalId,
   $$Array,
   $$BigInt,
   Console,

lib/es6/Stdlib_Global.js

@@ -1 +1,12 @@
-/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */
+
+
+
+let TimeoutId = {};
+
+let IntervalId = {};
+
+export {
+  TimeoutId,
+  IntervalId,
+}
+/* No side effect */

lib/js/Stdlib.js

@@ -1,6 +1,7 @@
 'use strict';
 
 let Stdlib_Error = require("./Stdlib_Error.js");
+let Stdlib_Global = require("./Stdlib_Global.js");
 let Primitive_object = require("./Primitive_object.js");
 
 function assertEqual(a, b) {
@@ -18,6 +19,10 @@ function assertEqual(a, b) {
   };
 }
 
+let TimeoutId = Stdlib_Global.TimeoutId;
+
+let IntervalId = Stdlib_Global.IntervalId;
+
 let $$Array;
 
 let $$BigInt;
@@ -108,6 +113,8 @@ let $$BigUint64Array;
 
 let panic = Stdlib_Error.panic;
 
+exports.TimeoutId = TimeoutId;
+exports.IntervalId = IntervalId;
 exports.$$Array = $$Array;
 exports.$$BigInt = $$BigInt;
 exports.Console = Console;

lib/js/Stdlib_Global.js

@@ -1 +1,10 @@
-/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */
+'use strict';
+
+
+let TimeoutId = {};
+
+let IntervalId = {};
+
+exports.TimeoutId = TimeoutId;
+exports.IntervalId = IntervalId;
+/* No side effect */

runtime/Stdlib_Array.res

@@ -270,3 +270,5 @@ let findMap = (arr, f) => {
 @send external at: (array<'a>, int) => option<'a> = "at"
 
 let last = a => a->get(a->length - 1)
+
+external ignore: array<'a> => unit = "%ignore"

runtime/Stdlib_Array.resi

@@ -1255,3 +1255,11 @@ Returns `None` if the array is empty.
 ```
 */
 let last: array<'a> => option<'a>
+
+/**
+  `ignore(array)` ignores the provided array and returns unit.
+
+  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)
+  without having to store or process it further.
+*/
+external ignore: array<'a> => unit = "%ignore"

runtime/Stdlib_AsyncIterator.res

@@ -35,3 +35,5 @@ let make: (unit => promise<value<'value>>) => t<'value> = %raw(`function makeAsy
     }
   }
 }`)
+
+external ignore: t<'a> => unit = "%ignore"

runtime/Stdlib_AsyncIterator.resi

@@ -186,3 +186,12 @@ main()->ignore
 ```
 */
 let forEach: (t<'a>, option<'a> => unit) => promise<unit>
+
+/**
+  `ignore(iterator)` ignores the provided async iterator and returns unit.
+
+  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)
+  without having to store or process it further.
+
+*/
+external ignore: t<'a> => unit = "%ignore"

runtime/Stdlib_BigInt.res

@@ -92,3 +92,11 @@ external lsl: (bigint, bigint) => bigint = "%lslbigint"
 external asr: (bigint, bigint) => bigint = "%asrbigint"
 
 let lnot = x => lxor(x, -1n)
+
+/**
+  `ignore(bigint)` ignores the provided bigint and returns unit.
+
+  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)
+  without having to store or process it further.
+*/
+external ignore: bigint => unit = "%ignore"

runtime/Stdlib_BigInt64Array.res

@@ -52,3 +52,11 @@ external fromArrayLikeOrIterable: 'a => t = "BigInt64Array.from"
 */
 @val
 external fromArrayLikeOrIterableWithMap: ('a, ('b, int) => bigint) => t = "BigInt64Array.from"
+
+/**
+  `ignore(bigIntArray)` ignores the provided bigIntArray and returns unit.
+
+  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)
+  without having to store or process it further.
+*/
+external ignore: t => unit = "%ignore"

runtime/Stdlib_BigUint64Array.res

@@ -52,3 +52,11 @@ external fromArrayLikeOrIterable: 'a => t = "BigUint64Array.from"
 */
 @val
 external fromArrayLikeOrIterableWithMap: ('a, ('b, int) => bigint) => t = "BigUint64Array.from"
+
+/**
+  `ignore(bigUintArray)` ignores the provided bigUintArray and returns unit.
+
+  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)
+  without having to store or process it further.
+*/
+external ignore: t => unit = "%ignore"

runtime/Stdlib_DataView.res

@@ -35,3 +35,11 @@ external fromBufferWithRange: (Stdlib_ArrayBuffer.t, ~byteOffset: int, ~length:
 
 @send external setBigInt64: (t, int, bigint) => unit = "setBigInt64"
 @send external setBigUint64: (t, int, bigint) => unit = "setBigUint64"
+
+/**
+  `ignore(dataView)` ignores the provided dataView and returns unit.
+
+  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)
+  without having to store or process it further.
+*/
+external ignore: t => unit = "%ignore"

runtime/Stdlib_Date.res

@@ -178,3 +178,5 @@ external toLocaleTimeStringWithLocaleAndOptions: (t, string, localeOptions) => s
 @send external toISOString: t => string = "toISOString"
 @send external toUTCString: t => string = "toUTCString"
 @return(nullable) @send external toJSON: t => option<string> = "toJSON"
+
+external ignore: t => unit = "%ignore"

runtime/Stdlib_Date.resi

@@ -1358,3 +1358,11 @@ Date.fromString("")->Date.toJSON
 @return(nullable)
 @send
 external toJSON: t => option<string> = "toJSON"
+
+/**
+  `ignore(date)` ignores the provided date and returns unit.
+
+  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)
+  without having to store or process it further.
+*/
+external ignore: t => unit = "%ignore"

runtime/Stdlib_Dict.res

@@ -42,3 +42,5 @@ let mapValues = (dict, f) => {
 }
 
 let has: (dict<'a>, string) => bool = %raw(`(dict, key) => key in dict`)
+
+external ignore: dict<'a> => unit = "%ignore"

runtime/Stdlib_Dict.resi

@@ -257,3 +257,11 @@ dict->Dict.has("key3") // false
 ```
 */
 let has: (dict<'a>, string) => bool
+
+/**
+  `ignore(dict)` ignores the provided dict and returns unit.
+
+  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)
+  without having to store or process it further.
+*/
+external ignore: dict<'a> => unit = "%ignore"

runtime/Stdlib_Error.res

@@ -41,3 +41,5 @@ module URIError = {
 external raise: t => 'a = "%raise"
 
 let panic = msg => make(`Panic! ${msg}`)->raise
+
+external ignore: t => unit = "%ignore"

runtime/Stdlib_Error.resi

@@ -180,3 +180,11 @@ try {
 ```
 */
 let panic: string => 'a
+
+/**
+  `ignore(error)` ignores the provided error and returns unit.
+
+  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)
+  without having to store or process it further.
+*/
+external ignore: t => unit = "%ignore"

runtime/Stdlib_Exn.res

@@ -88,3 +88,5 @@ exception TypeError of error
  The URIError object represents an error when a global URI handling function was used in a wrong way. 
 exception URIError of error    
 */
+
+external ignore: t => unit = "%ignore"

runtime/Stdlib_Exn.resi

@@ -59,3 +59,11 @@ let raiseReferenceError: string => 'a
 let raiseSyntaxError: string => 'a
 let raiseTypeError: string => 'a
 let raiseUriError: string => 'a
+
+/**
+  `ignore(exn)` ignores the provided exn and returns unit.
+
+  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)
+  without having to store or process it further.
+*/
+external ignore: t => unit = "%ignore"

runtime/Stdlib_Float.res

@@ -59,3 +59,5 @@ let clamp = (~min=?, ~max=?, value): float => {
   | _ => value
   }
 }
+
+external ignore: float => unit = "%ignore"

runtime/Stdlib_Float.resi

@@ -462,3 +462,11 @@ Float.clamp(4.2, ~min=4.3, ~max=4.1) == 4.3
 ```
 */
 let clamp: (~min: float=?, ~max: float=?, float) => float
+
+/**
+  `ignore(float)` ignores the provided float and returns unit.
+
+  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)
+  without having to store or process it further.
+*/
+external ignore: float => unit = "%ignore"

runtime/Stdlib_Float32Array.res

@@ -52,3 +52,11 @@ external fromArrayLikeOrIterable: 'a => t = "Float32Array.from"
 */
 @val
 external fromArrayLikeOrIterableWithMap: ('a, ('b, int) => float) => t = "Float32Array.from"
+
+/**
+  `ignore(floatArray)` ignores the provided floatArray and returns unit.
+
+  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)
+  without having to store or process it further.
+*/
+external ignore: t => unit = "%ignore"

runtime/Stdlib_Float64Array.res

@@ -52,3 +52,11 @@ external fromArrayLikeOrIterable: 'a => t = "Float64Array.from"
 */
 @val
 external fromArrayLikeOrIterableWithMap: ('a, ('b, int) => float) => t = "Float64Array.from"
+
+/**
+  `ignore(floatArray)` ignores the provided floatArray and returns unit.
+
+  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)
+  without having to store or process it further.
+*/
+external ignore: t => unit = "%ignore"

runtime/Stdlib_Global.res

@@ -15,3 +15,11 @@ type intervalId
 
 @val external encodeURIComponent: string => string = "encodeURIComponent"
 @val external decodeURIComponent: string => string = "decodeURIComponent"
+
+module TimeoutId = {
+  external ignore: timeoutId => unit = "%ignore"
+}
+
+module IntervalId = {
+  external ignore: intervalId => unit = "%ignore"
+}

runtime/Stdlib_Global.resi

@@ -199,3 +199,23 @@ Console.log(decodeURIComponent("array%3D%5BsomeValue%5D"))
 */
 @val
 external decodeURIComponent: string => string = "decodeURIComponent"
+
+module TimeoutId: {
+  /**
+    `ignore(timeoutId)` ignores the provided timeoutId and returns unit.
+
+    This helper is useful when you want to discard a value (for example, the result of an operation with side effects)
+    without having to store or process it further.
+*/
+  external ignore: timeoutId => unit = "%ignore"
+}
+
+module IntervalId: {
+  /**
+    `ignore(intervalId)` ignores the provided intervalId and returns unit.
+
+    This helper is useful when you want to discard a value (for example, the result of an operation with side effects)
+    without having to store or process it further.
+  */
+  external ignore: intervalId => unit = "%ignore"
+}

runtime/Stdlib_Int.res

@@ -106,3 +106,5 @@ module Bitwise = {
 
   let lnot = x => lxor(x, -1)
 }
+
+external ignore: int => unit = "%ignore"

runtime/Stdlib_Int.resi

@@ -471,3 +471,11 @@ module Bitwise: {
   */
   external asr: (int, int) => int = "%asrint"
 }
+
+/**
+  `ignore(int)` ignores the provided int and returns unit.
+
+  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)
+  without having to store or process it further.
+*/
+external ignore: int => unit = "%ignore"

runtime/Stdlib_Int16Array.res

@@ -52,3 +52,11 @@ external fromArrayLikeOrIterable: 'a => t = "Int16Array.from"
 */
 @val
 external fromArrayLikeOrIterableWithMap: ('a, ('b, int) => int) => t = "Int16Array.from"
+
+/**
+  `ignore(intArray)` ignores the provided intArray and returns unit.
+
+  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)
+  without having to store or process it further.
+*/
+external ignore: t => unit = "%ignore"

runtime/Stdlib_Int32Array.res

@@ -52,3 +52,11 @@ external fromArrayLikeOrIterable: 'a => t = "Int32Array.from"
 */
 @val
 external fromArrayLikeOrIterableWithMap: ('a, ('b, int) => int) => t = "Int32Array.from"
+
+/**
+  `ignore(intArray)` ignores the provided intArray and returns unit.
+
+  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)
+  without having to store or process it further.
+*/
+external ignore: t => unit = "%ignore"

runtime/Stdlib_Int8Array.res

@@ -52,3 +52,11 @@ external fromArrayLikeOrIterable: 'a => t = "Int8Array.from"
 */
 @val
 external fromArrayLikeOrIterableWithMap: ('a, ('b, int) => int) => t = "Int8Array.from"
+
+/**
+  `ignore(intArray)` ignores the provided intArray and returns unit.
+
+  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)
+  without having to store or process it further.
+*/
+external ignore: t => unit = "%ignore"

runtime/Stdlib_Intl_Collator.res

@@ -34,3 +34,11 @@ external supportedLocalesOf: (array<string>, ~options: supportedLocalesOptions=?
 @send external resolvedOptions: t => resolvedOptions = "resolvedOptions"
 
 @send external compare: (t, string, string) => int = "compare"
+
+/**
+  `ignore(collator)` ignores the provided collator and returns unit.
+
+  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)
+  without having to store or process it further.
+*/
+external ignore: t => unit = "%ignore"

runtime/Stdlib_Intl_DateTimeFormat.res

@@ -127,3 +127,11 @@ external formatRangeToParts: (
   ~startDate: Stdlib_Date.t,
   ~endDate: Stdlib_Date.t,
 ) => array<dateTimeRangePart> = "formatRangeToParts"
+
+/**
+  `ignore(dateTimeFormat)` ignores the provided dateTimeFormat and returns unit.
+
+  This helper is useful when you want to discard a value (for example, the result of an operation with side effects)
+  without having to store or process it further.
+*/
+external ignore: t => unit = "%ignore"