Add isEmpty function to Array, Dict, Map, Set with corresponding documentation

DZakh · DZakh · commit 16962099c364 · 2025-05-24T18:25:15.000+04:00
diff --git a/lib/es6/Stdlib_Array.js b/lib/es6/Stdlib_Array.js
@@ -22,6 +22,10 @@ function fromInitializer(length, f) {
   return arr;
 }
 
+function isEmpty(arr) {
+  return arr.length === 0;
+}
+
 function equal(a, b, eq) {
   let len = a.length;
   if (len === b.length) {
@@ -183,6 +187,7 @@ export {
   fromInitializer,
   equal,
   compare,
+  isEmpty,
   indexOfOpt,
   lastIndexOfOpt,
   reduce,
diff --git a/lib/es6/Stdlib_Dict.js b/lib/es6/Stdlib_Dict.js
@@ -9,6 +9,10 @@ function size(dict) {
   return Object.keys(dict).length;
 }
 
+function isEmpty(dict) {
+  return Object.keys(dict).length === 0;
+}
+
 function forEach(dict, f) {
   Object.values(dict).forEach(value => f(value));
 }
@@ -29,6 +33,7 @@ function mapValues(dict, f) {
 export {
   $$delete$1 as $$delete,
   size,
+  isEmpty,
   forEach,
   forEachWithKey,
   mapValues,
diff --git a/lib/es6/Stdlib_Map.js b/lib/es6/Stdlib_Map.js
@@ -1 +1,11 @@
-/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */
+
+
+
+function isEmpty(map) {
+  return map.size === 0;
+}
+
+export {
+  isEmpty,
+}
+/* No side effect */
diff --git a/lib/es6/Stdlib_Set.js b/lib/es6/Stdlib_Set.js
@@ -1 +1,11 @@
-/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */
+
+
+
+function isEmpty(set) {
+  return set.size === 0;
+}
+
+export {
+  isEmpty,
+}
+/* No side effect */
diff --git a/lib/js/Stdlib_Array.js b/lib/js/Stdlib_Array.js
@@ -22,6 +22,10 @@ function fromInitializer(length, f) {
   return arr;
 }
 
+function isEmpty(arr) {
+  return arr.length === 0;
+}
+
 function equal(a, b, eq) {
   let len = a.length;
   if (len === b.length) {
@@ -182,6 +186,7 @@ exports.make = make;
 exports.fromInitializer = fromInitializer;
 exports.equal = equal;
 exports.compare = compare;
+exports.isEmpty = isEmpty;
 exports.indexOfOpt = indexOfOpt;
 exports.lastIndexOfOpt = lastIndexOfOpt;
 exports.reduce = reduce;
diff --git a/lib/js/Stdlib_Dict.js b/lib/js/Stdlib_Dict.js
@@ -9,6 +9,10 @@ function size(dict) {
   return Object.keys(dict).length;
 }
 
+function isEmpty(dict) {
+  return Object.keys(dict).length === 0;
+}
+
 function forEach(dict, f) {
   Object.values(dict).forEach(value => f(value));
 }
@@ -28,6 +32,7 @@ function mapValues(dict, f) {
 
 exports.$$delete = $$delete$1;
 exports.size = size;
+exports.isEmpty = isEmpty;
 exports.forEach = forEach;
 exports.forEachWithKey = forEachWithKey;
 exports.mapValues = mapValues;
diff --git a/lib/js/Stdlib_Map.js b/lib/js/Stdlib_Map.js
@@ -1 +1,9 @@
-/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */
+'use strict';
+
+
+function isEmpty(map) {
+  return map.size === 0;
+}
+
+exports.isEmpty = isEmpty;
+/* No side effect */
diff --git a/lib/js/Stdlib_Set.js b/lib/js/Stdlib_Set.js
@@ -1 +1,9 @@
-/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */
+'use strict';
+
+
+function isEmpty(set) {
+  return set.size === 0;
+}
+
+exports.isEmpty = isEmpty;
+/* No side effect */
diff --git a/runtime/Stdlib_Array.res b/runtime/Stdlib_Array.res
@@ -43,6 +43,8 @@ let fromInitializer = (~length, f) =>
 
 @get external length: array<'a> => int = "length"
 
+let isEmpty = arr => arr->length === 0
+
 let rec equalFromIndex = (a, b, i, eq, len) =>
   if i === len {
     true
diff --git a/runtime/Stdlib_Array.resi b/runtime/Stdlib_Array.resi
@@ -87,6 +87,24 @@ someArray
 @get
 external length: array<'a> => int = "length"
 
+/**
+`isEmpty(array)` returns `true` if the array is empty (has length 0), `false` otherwise.
+
+## Examples
+
+```rescript
+[]->Array.isEmpty->assertEqual(true)
+[1, 2, 3]->Array.isEmpty->assertEqual(false)
+
+let emptyArray = []
+emptyArray->Array.isEmpty->assertEqual(true)
+
+let nonEmptyArray = ["hello"]
+nonEmptyArray->Array.isEmpty->assertEqual(false)
+```
+*/
+let isEmpty: array<'a> => bool
+
 // TODO: Docs
 @send external copyAllWithin: (array<'a>, ~target: int) => array<'a> = "copyWithin"
 
@@ -929,7 +947,7 @@ external mapWithIndex: (array<'a>, ('a, int) => 'b) => array<'b> = "map"
 /**
 `reduce(xs, init, fn)`
 
-Applies `fn` to each element of `xs` from beginning to end. Function `fn` has two parameters: the item from the list and an “accumulator”; which starts with a value of `init`. `reduce` returns the final value of the accumulator.
+Applies `fn` to each element of `xs` from beginning to end. Function `fn` has two parameters: the item from the list and an "accumulator"; which starts with a value of `init`. `reduce` returns the final value of the accumulator.
 
 ## Examples
 
@@ -950,7 +968,7 @@ let reduce: (array<'a>, 'b, ('b, 'a) => 'b) => 'b
 /**
 `reduceWithIndex(x, init, fn)`
 
-Applies `fn` to each element of `xs` from beginning to end. Function `fn` has three parameters: the item from the array and an “accumulator”, which starts with a value of `init` and the index of each element. `reduceWithIndex` returns the final value of the accumulator.
+Applies `fn` to each element of `xs` from beginning to end. Function `fn` has three parameters: the item from the array and an "accumulator", which starts with a value of `init` and the index of each element. `reduceWithIndex` returns the final value of the accumulator.
 
 ## Examples
 
diff --git a/runtime/Stdlib_Dict.res b/runtime/Stdlib_Dict.res
@@ -20,6 +20,8 @@ let delete = (dict, string) => {
 
 let size = dict => dict->keysToArray->Stdlib_Array.length
 
+let isEmpty = dict => dict->size === 0
+
 @val external valuesToArray: dict<'a> => array<'a> = "Object.values"
 
 @val external assign: (dict<'a>, dict<'a>) => dict<'a> = "Object.assign"
diff --git a/runtime/Stdlib_Dict.resi b/runtime/Stdlib_Dict.resi
@@ -164,6 +164,25 @@ dict->Dict.size->assertEqual(1)
 */
 let size: dict<'a> => int
 
+/**
+`isEmpty(dictionary)` returns `true` if the dictionary is empty (has no key/value pairs), `false` otherwise.
+
+## Examples
+```rescript
+let emptyDict = Dict.make()
+emptyDict->Dict.isEmpty->assertEqual(true)
+
+let dict = Dict.make()
+dict->Dict.set("someKey", 1)
+dict->Dict.isEmpty->assertEqual(false)
+
+// After clearing all keys
+dict->Dict.delete("someKey")
+dict->Dict.isEmpty->assertEqual(true)
+```
+*/
+let isEmpty: dict<'a> => bool
+
 /**
 `valuesToArray(dictionary)` returns an array of all the values of the dictionary.
 
diff --git a/runtime/Stdlib_Map.res b/runtime/Stdlib_Map.res
@@ -7,6 +7,8 @@ type t<'k, 'v>
 
 @get external size: t<'k, 'v> => int = "size"
 
+let isEmpty = map => map->size === 0
+
 @send external clear: t<'k, 'v> => unit = "clear"
 
 @send external forEach: (t<'k, 'v>, 'v => unit) => unit = "forEach"
diff --git a/runtime/Stdlib_Map.resi b/runtime/Stdlib_Map.resi
@@ -96,6 +96,25 @@ let size = map->Map.size // 1
 @get
 external size: t<'k, 'v> => int = "size"
 
+/**
+`isEmpty(map)` returns `true` if the map has no key/value pairs, `false` otherwise.
+
+## Examples
+```rescript
+let emptyMap = Map.make()
+emptyMap->Map.isEmpty->assertEqual(true)
+
+let map = Map.make()
+map->Map.set("someKey", "someValue")
+map->Map.isEmpty->assertEqual(false)
+
+// After clearing the map
+map->Map.clear
+map->Map.isEmpty->assertEqual(true)
+```
+*/
+let isEmpty: t<'k, 'v> => bool
+
 /**
 Clears all entries in the map.
 
diff --git a/runtime/Stdlib_Set.res b/runtime/Stdlib_Set.res
@@ -7,6 +7,8 @@ type t<'a>
 
 @get external size: t<'a> => int = "size"
 
+let isEmpty = set => set->size === 0
+
 @send external clear: t<'a> => unit = "clear"
 
 @send external add: (t<'a>, 'a) => unit = "add"
diff --git a/runtime/Stdlib_Set.resi b/runtime/Stdlib_Set.resi
@@ -95,6 +95,25 @@ let size = set->Set.size // 2
 @get
 external size: t<'a> => int = "size"
 
+/**
+`isEmpty(set)` returns `true` if the set has no values, `false` otherwise.
+
+## Examples
+```rescript
+let emptySet = Set.make()
+emptySet->Set.isEmpty->assertEqual(true)
+
+let set = Set.make()
+set->Set.add("someValue")
+set->Set.isEmpty->assertEqual(false)
+
+// After clearing the set
+set->Set.clear
+set->Set.isEmpty->assertEqual(true)
+```
+*/
+let isEmpty: t<'a> => bool
+
 /**
 Clears all entries in the set.
 
