rephrase ignore documentation

tsnobip · tsnobip · commit 83142d31e078 · 2025-03-18T17:35:49.000+01:00
diff --git a/runtime/Stdlib_Array.resi b/runtime/Stdlib_Array.resi
@@ -1259,7 +1259,7 @@ 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 a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_AsyncIterator.resi b/runtime/Stdlib_AsyncIterator.resi
@@ -190,7 +190,7 @@ 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 a side-effecting operation)
+  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.
 
 */
diff --git a/runtime/Stdlib_BigInt.res b/runtime/Stdlib_BigInt.res
@@ -96,7 +96,7 @@ 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 a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_BigInt64Array.res b/runtime/Stdlib_BigInt64Array.res
@@ -56,7 +56,7 @@ external fromArrayLikeOrIterableWithMap: ('a, ('b, int) => bigint) => t = "BigIn
 /**
   `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 a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_BigUint64Array.res b/runtime/Stdlib_BigUint64Array.res
@@ -56,7 +56,7 @@ external fromArrayLikeOrIterableWithMap: ('a, ('b, int) => bigint) => t = "BigUi
 /**
   `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 a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_DataView.res b/runtime/Stdlib_DataView.res
@@ -39,7 +39,7 @@ external fromBufferWithRange: (Stdlib_ArrayBuffer.t, ~byteOffset: int, ~length:
 /**
   `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 a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Date.resi b/runtime/Stdlib_Date.resi
@@ -1362,7 +1362,7 @@ 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 a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Dict.resi b/runtime/Stdlib_Dict.resi
@@ -261,7 +261,7 @@ 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 a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Error.resi b/runtime/Stdlib_Error.resi
@@ -184,7 +184,7 @@ 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 a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Exn.resi b/runtime/Stdlib_Exn.resi
@@ -63,7 +63,7 @@ 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 a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Float.resi b/runtime/Stdlib_Float.resi
@@ -466,7 +466,7 @@ 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 a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Float32Array.res b/runtime/Stdlib_Float32Array.res
@@ -56,7 +56,7 @@ external fromArrayLikeOrIterableWithMap: ('a, ('b, int) => float) => t = "Float3
 /**
   `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 a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Float64Array.res b/runtime/Stdlib_Float64Array.res
@@ -56,7 +56,7 @@ external fromArrayLikeOrIterableWithMap: ('a, ('b, int) => float) => t = "Float6
 /**
   `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 a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Global.resi b/runtime/Stdlib_Global.resi
@@ -204,7 +204,7 @@ 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 a side-effecting operation)
+    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"
@@ -214,7 +214,7 @@ 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 a side-effecting operation)
+    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"
diff --git a/runtime/Stdlib_Int.resi b/runtime/Stdlib_Int.resi
@@ -475,7 +475,7 @@ module Bitwise: {
 /**
   `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 a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Int16Array.res b/runtime/Stdlib_Int16Array.res
@@ -56,7 +56,7 @@ external fromArrayLikeOrIterableWithMap: ('a, ('b, int) => int) => t = "Int16Arr
 /**
   `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 a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Int32Array.res b/runtime/Stdlib_Int32Array.res
@@ -56,7 +56,7 @@ external fromArrayLikeOrIterableWithMap: ('a, ('b, int) => int) => t = "Int32Arr
 /**
   `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 a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Int8Array.res b/runtime/Stdlib_Int8Array.res
@@ -56,7 +56,7 @@ external fromArrayLikeOrIterableWithMap: ('a, ('b, int) => int) => t = "Int8Arra
 /**
   `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 a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Intl_Collator.res b/runtime/Stdlib_Intl_Collator.res
@@ -38,7 +38,7 @@ external supportedLocalesOf: (array<string>, ~options: supportedLocalesOptions=?
 /**
   `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 a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Intl_DateTimeFormat.res b/runtime/Stdlib_Intl_DateTimeFormat.res
@@ -131,7 +131,7 @@ external 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 a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Intl_ListFormat.res b/runtime/Stdlib_Intl_ListFormat.res
@@ -49,7 +49,7 @@ external supportedLocalesOf: (array<string>, ~options: supportedLocalesOptions=?
 /**
   `ignore(listFormat)` ignores the provided listFormat and returns unit.
 
-  This helper is useful when you want to discard a value (for example, the result of a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Intl_Locale.res b/runtime/Stdlib_Intl_Locale.res
@@ -32,7 +32,7 @@ type options = {
 /**
   `ignore(locale)` ignores the provided locale and returns unit.
 
-  This helper is useful when you want to discard a value (for example, the result of a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Intl_NumberFormat.res b/runtime/Stdlib_Intl_NumberFormat.res
@@ -213,7 +213,7 @@ external formatStringToParts: (t, string) => array<numberFormatRangePart> = "for
 /**
   `ignore(numberGrouping)` ignores the provided numberGrouping and returns unit.
 
-  This helper is useful when you want to discard a value (for example, the result of a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Intl_NumberFormat_Grouping.res b/runtime/Stdlib_Intl_NumberFormat_Grouping.res
@@ -17,7 +17,7 @@ let parseJsValue = value =>
 /**
   `ignore(grouping)` ignores the provided grouping and returns unit.
 
-  This helper is useful when you want to discard a value (for example, the result of a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Intl_PluralRules.res b/runtime/Stdlib_Intl_PluralRules.res
@@ -64,7 +64,7 @@ external selectRangeBigInt: (t, ~start: bigint, ~end: bigint) => rule = "selectR
 /**
   `ignore(pluralRules)` ignores the provided pluralRules and returns unit.
 
-  This helper is useful when you want to discard a value (for example, the result of a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Intl_RelativeTimeFormat.res b/runtime/Stdlib_Intl_RelativeTimeFormat.res
@@ -42,7 +42,7 @@ external formatToParts: (t, int, timeUnit) => array<relativeTimePart> = "formatT
 /**
   `ignore(relativeTimeFormat)` ignores the provided relativeTimeFormat and returns unit.
 
-  This helper is useful when you want to discard a value (for example, the result of a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Intl_Segmenter.res b/runtime/Stdlib_Intl_Segmenter.res
@@ -36,7 +36,7 @@ external supportedLocalesOf: (array<string>, ~options: supportedLocalesOptions=?
 /**
   `ignore(segmenter)` ignores the provided segmenter and returns unit.
 
-  This helper is useful when you want to discard a value (for example, the result of a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Intl_Segments.res b/runtime/Stdlib_Intl_Segments.res
@@ -20,7 +20,7 @@ external containingWithIndex: (t, int) => segmentData = "containing"
 /**
   `ignore(segments)` ignores the provided segments and returns unit.
 
-  This helper is useful when you want to discard a value (for example, the result of a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Iterator.resi b/runtime/Stdlib_Iterator.resi
@@ -117,7 +117,7 @@ let forEach: (t<'a>, option<'a> => unit) => unit
 /**
   `ignore(iterator)` ignores the provided iterator and returns unit.
 
-  This helper is useful when you want to discard a value (for example, the result of a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_JSON.resi b/runtime/Stdlib_JSON.resi
@@ -802,7 +802,7 @@ module Decode: {
 /**
   `ignore(json)` ignores the provided json and returns unit.
 
-  This helper is useful when you want to discard a value (for example, the result of a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_List.resi b/runtime/Stdlib_List.resi
@@ -902,7 +902,7 @@ let sort: (list<'a>, ('a, 'a) => Stdlib_Ordering.t) => list<'a>
 /**
   `ignore(list)` ignores the provided list and returns unit.
 
-  This helper is useful when you want to discard a value (for example, the result of a side-effecting operation)
+  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: list<'a> => unit = "%ignore"
diff --git a/runtime/Stdlib_Map.resi b/runtime/Stdlib_Map.resi
@@ -281,7 +281,7 @@ external entries: t<'k, 'v> => Stdlib_Iterator.t<('k, 'v)> = "entries"
 /**
   `ignore(map)` ignores the provided map and returns unit.
 
-  This helper is useful when you want to discard a value (for example, the result of a side-effecting operation)
+  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<'k, 'v> => unit = "%ignore"
diff --git a/runtime/Stdlib_Null.resi b/runtime/Stdlib_Null.resi
@@ -209,7 +209,7 @@ let flatMap: (t<'a>, 'a => t<'b>) => t<'b>
 /**
   `ignore(null)` ignores the provided null and returns unit.
 
-  This helper is useful when you want to discard a value (for example, the result of a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Nullable.resi b/runtime/Stdlib_Nullable.resi
@@ -245,7 +245,7 @@ let flatMap: (t<'a>, 'a => t<'b>) => t<'b>
 /**
   `ignore(nullable)` ignores the provided nullable and returns unit.
 
-  This helper is useful when you want to discard a value (for example, the result of a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Object.res b/runtime/Stdlib_Object.res
@@ -301,7 +301,7 @@ external isExtensible: 'a => bool = "Object.isExtensible"
 /**
   `ignore(object)` ignores the provided object and returns unit.
 
-  This helper is useful when you want to discard a value (for example, the result of a side-effecting operation)
+  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: {..} => unit = "%ignore"
diff --git a/runtime/Stdlib_Option.resi b/runtime/Stdlib_Option.resi
@@ -320,7 +320,7 @@ let all6: ((option<'a>, option<'b>, option<'c>, option<'d>, option<'e>, option<'
 /**
   `ignore(option)` ignores the provided option and returns unit.
 
-  This helper is useful when you want to discard a value (for example, the result of a side-effecting operation)
+  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: option<'a> => unit = "%ignore"
diff --git a/runtime/Stdlib_Ordering.res b/runtime/Stdlib_Ordering.res
@@ -15,7 +15,7 @@ let fromInt = n => n < 0 ? less : n > 0 ? greater : equal
 /**
   `ignore(ordering)` ignores the provided ordering and returns unit.
 
-  This helper is useful when you want to discard a value (for example, the result of a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Promise.resi b/runtime/Stdlib_Promise.resi
@@ -457,7 +457,7 @@ external done: promise<'a> => unit = "%ignore"
 /**
   `ignore(promise)` ignores the provided promise and returns unit.
 
-  This helper is useful when you want to discard a value (for example, the result of a side-effecting operation)
+  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: promise<'a> => unit = "%ignore"
diff --git a/runtime/Stdlib_RegExp.resi b/runtime/Stdlib_RegExp.resi
@@ -292,7 +292,7 @@ external unicode: t => bool = "unicode"
 /**
   `ignore(regExp)` ignores the provided regExp and returns unit.
 
-  This helper is useful when you want to discard a value (for example, the result of a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_Result.resi b/runtime/Stdlib_Result.resi
@@ -292,7 +292,7 @@ let all6: (
 /**
   `ignore(result)` ignores the provided result and returns unit.
 
-  This helper is useful when you want to discard a value (for example, the result of a side-effecting operation)
+  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: result<'res, 'err> => unit = "%ignore"
diff --git a/runtime/Stdlib_Set.resi b/runtime/Stdlib_Set.resi
@@ -330,7 +330,7 @@ external toArray: t<'a> => array<'a> = "Array.from"
 /**
   `ignore(set)` ignores the provided set and returns unit.
 
-  This helper is useful when you want to discard a value (for example, the result of a side-effecting operation)
+  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"
diff --git a/runtime/Stdlib_String.resi b/runtime/Stdlib_String.resi
diff --git a/runtime/Stdlib_Symbol.resi b/runtime/Stdlib_Symbol.resi
diff --git a/runtime/Stdlib_Type.resi b/runtime/Stdlib_Type.resi
diff --git a/runtime/Stdlib_TypedArray.res b/runtime/Stdlib_TypedArray.res
diff --git a/runtime/Stdlib_Uint16Array.res b/runtime/Stdlib_Uint16Array.res
diff --git a/runtime/Stdlib_Uint32Array.res b/runtime/Stdlib_Uint32Array.res
diff --git a/runtime/Stdlib_Uint8Array.res b/runtime/Stdlib_Uint8Array.res
diff --git a/runtime/Stdlib_Uint8ClampedArray.res b/runtime/Stdlib_Uint8ClampedArray.res
diff --git a/runtime/Stdlib_WeakMap.res b/runtime/Stdlib_WeakMap.res
diff --git a/runtime/Stdlib_WeakSet.res b/runtime/Stdlib_WeakSet.res
diff --git a/tests/analysis_tests/tests/src/expected/Completion.res.txt b/tests/analysis_tests/tests/src/expected/Completion.res.txt
diff --git a/tests/analysis_tests/tests/src/expected/CompletionJsx.res.txt b/tests/analysis_tests/tests/src/expected/CompletionJsx.res.txt
