refactor: m_ => mut_

Author: RebeccaStevens

benchmark/run.ts

@@ -44,16 +44,16 @@ const benchmarkDataSets: Array<{
     return data;
   });
 
-for (let m_i = 0; m_i < benchmarkDataSets.length; m_i++) {
-  const { name: benchmarkName, data: benchmarkData } = benchmarkDataSets[m_i];
+for (let mut_i = 0; mut_i < benchmarkDataSets.length; mut_i++) {
+  const { name: benchmarkName, data: benchmarkData } = benchmarkDataSets[mut_i];
   const bench = new Bench({
     time: 10_000,
     iterations: 1,
     warmupTime: 1000,
     warmupIterations: 1,
   });
 
-  console.log(`\nRunning benchmarks for data set "${benchmarkName}" (${m_i + 1} of ${benchmarkDataSets.length}):\n`);
+  console.log(`\nRunning benchmarks for data set "${benchmarkName}" (${mut_i + 1} of ${benchmarkDataSets.length}):\n`);
 
   bench
     .add("deepmerge-ts", () => {
@@ -84,7 +84,7 @@ for (let m_i = 0; m_i < benchmarkDataSets.length; m_i++) {
 function generateBenchmarkDataSet(name: string, items: number, maxProperties: number, maxDepth: number) {
   const data: object[] = [];
 
-  for (let m_i = 0; m_i < items; m_i++) {
+  for (let mut_i = 0; mut_i < items; mut_i++) {
     data.push(generateBenchmarkDataItem(maxProperties, maxDepth));
   }
 
@@ -101,8 +101,8 @@ function generateBenchmarkDataItem(maxProperties: number, depth: number, current
 
   const propertiesOptions = shuffle(Array.from({ length: maxProperties }, (_, i) => String.fromCodePoint(i + 65)));
 
-  for (let m_i = 0; m_i < properties; m_i++) {
-    const prop = propertiesOptions[m_i];
+  for (let mut_i = 0; mut_i < properties; mut_i++) {
+    const prop = propertiesOptions[mut_i];
 
     obj[prop] = currentDepth < depth ? generateBenchmarkDataItem(maxProperties, depth, currentDepth + 1) : "value";
   }
@@ -111,14 +111,14 @@ function generateBenchmarkDataItem(maxProperties: number, depth: number, current
 }
 
 function shuffle<T>(array: T[]) {
-  let m_currentIndex = array.length;
-  let m_randomIndex;
+  let mut_currentIndex = array.length;
+  let mut_randomIndex;
 
-  while (m_currentIndex !== 0) {
-    m_randomIndex = Math.floor(Math.random() * m_currentIndex);
-    m_currentIndex--;
+  while (mut_currentIndex !== 0) {
+    mut_randomIndex = Math.floor(Math.random() * mut_currentIndex);
+    mut_currentIndex--;
 
-    [array[m_currentIndex], array[m_randomIndex]] = [array[m_randomIndex], array[m_currentIndex]];
+    [array[mut_currentIndex], array[mut_randomIndex]] = [array[mut_randomIndex], array[mut_currentIndex]];
   }
 
   return array;

src/deepmerge-into.ts

@@ -130,7 +130,7 @@ function getIntoUtils<M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInM
 /**
  * Merge unknown things into a target.
  *
- * @param m_target - The target to merge into.
+ * @param mut_target - The target to merge into.
  * @param values - The values.
  */
 export function mergeUnknownsInto<
@@ -139,7 +139,7 @@ export function mergeUnknownsInto<
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
-  m_target: Reference<unknown>,
+  mut_target: Reference<unknown>,
   values: Ts,
   utils: U,
   meta: M | undefined,
@@ -151,25 +151,25 @@ export function mergeUnknownsInto<
     return;
   }
   if (filteredValues.length === 1) {
-    return void mergeOthersInto<U, M, MM>(m_target, filteredValues, utils, meta);
+    return void mergeOthersInto<U, M, MM>(mut_target, filteredValues, utils, meta);
   }
 
-  const type = getObjectType(m_target.value);
+  const type = getObjectType(mut_target.value);
 
   if (type !== ObjectType.NOT && type !== ObjectType.OTHER) {
-    for (let m_index = 1; m_index < filteredValues.length; m_index++) {
-      if (getObjectType(filteredValues[m_index]) === type) {
+    for (let mut_index = 1; mut_index < filteredValues.length; mut_index++) {
+      if (getObjectType(filteredValues[mut_index]) === type) {
         continue;
       }
 
-      return void mergeOthersInto<U, M, MM>(m_target, filteredValues, utils, meta);
+      return void mergeOthersInto<U, M, MM>(mut_target, filteredValues, utils, meta);
     }
   }
 
   switch (type) {
     case ObjectType.RECORD: {
       return void mergeRecordsInto<U, M, MM>(
-        m_target as Reference<Record<PropertyKey, unknown>>,
+        mut_target as Reference<Record<PropertyKey, unknown>>,
         filteredValues as ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>,
         utils,
         meta,
@@ -178,7 +178,7 @@ export function mergeUnknownsInto<
 
     case ObjectType.ARRAY: {
       return void mergeArraysInto<U, M, MM>(
-        m_target as Reference<unknown[]>,
+        mut_target as Reference<unknown[]>,
         filteredValues as ReadonlyArray<ReadonlyArray<unknown>>,
         utils,
         meta,
@@ -187,7 +187,7 @@ export function mergeUnknownsInto<
 
     case ObjectType.SET: {
       return void mergeSetsInto<U, M, MM>(
-        m_target as Reference<Set<unknown>>,
+        mut_target as Reference<Set<unknown>>,
         filteredValues as ReadonlyArray<Readonly<ReadonlySet<unknown>>>,
         utils,
         meta,
@@ -196,40 +196,40 @@ export function mergeUnknownsInto<
 
     case ObjectType.MAP: {
       return void mergeMapsInto<U, M, MM>(
-        m_target as Reference<Map<unknown, unknown>>,
+        mut_target as Reference<Map<unknown, unknown>>,
         filteredValues as ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>,
         utils,
         meta,
       );
     }
 
     default: {
-      return void mergeOthersInto<U, M, MM>(m_target, filteredValues, utils, meta);
+      return void mergeOthersInto<U, M, MM>(mut_target, filteredValues, utils, meta);
     }
   }
 }
 
 /**
  * Merge records into a target record.
  *
- * @param m_target - The target to merge into.
+ * @param mut_target - The target to merge into.
  * @param values - The records.
  */
 function mergeRecordsInto<
   U extends DeepMergeIntoFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
-  m_target: Reference<Record<PropertyKey, unknown>>,
+  mut_target: Reference<Record<PropertyKey, unknown>>,
   values: ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>,
   utils: U,
   meta: M | undefined,
 ) {
-  const action = utils.mergeFunctions.mergeRecords(m_target, values, utils, meta);
+  const action = utils.mergeFunctions.mergeRecords(mut_target, values, utils, meta);
 
   if (action === actions.defaultMerge) {
     utils.defaultMergeFunctions.mergeRecords<ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>, U, M, MM>(
-      m_target,
+      mut_target,
       values,
       utils,
       meta,
@@ -240,81 +240,81 @@ function mergeRecordsInto<
 /**
  * Merge arrays into a target array.
  *
- * @param m_target - The target to merge into.
+ * @param mut_target - The target to merge into.
  * @param values - The arrays.
  */
 function mergeArraysInto<
   U extends DeepMergeIntoFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
->(m_target: Reference<unknown[]>, values: ReadonlyArray<ReadonlyArray<unknown>>, utils: U, meta: M | undefined) {
-  const action = utils.mergeFunctions.mergeArrays(m_target, values, utils, meta);
+>(mut_target: Reference<unknown[]>, values: ReadonlyArray<ReadonlyArray<unknown>>, utils: U, meta: M | undefined) {
+  const action = utils.mergeFunctions.mergeArrays(mut_target, values, utils, meta);
 
   if (action === actions.defaultMerge) {
-    utils.defaultMergeFunctions.mergeArrays(m_target, values);
+    utils.defaultMergeFunctions.mergeArrays(mut_target, values);
   }
 }
 
 /**
  * Merge sets into a target set.
  *
- * @param m_target - The target to merge into.
+ * @param mut_target - The target to merge into.
  * @param values - The sets.
  */
 function mergeSetsInto<
   U extends DeepMergeIntoFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
-  m_target: Reference<Set<unknown>>,
+  mut_target: Reference<Set<unknown>>,
   values: ReadonlyArray<Readonly<ReadonlySet<unknown>>>,
   utils: U,
   meta: M | undefined,
 ) {
-  const action = utils.mergeFunctions.mergeSets(m_target, values, utils, meta);
+  const action = utils.mergeFunctions.mergeSets(mut_target, values, utils, meta);
 
   if (action === actions.defaultMerge) {
-    utils.defaultMergeFunctions.mergeSets(m_target, values);
+    utils.defaultMergeFunctions.mergeSets(mut_target, values);
   }
 }
 
 /**
  * Merge maps into a target map.
  *
- * @param m_target - The target to merge into.
+ * @param mut_target - The target to merge into.
  * @param values - The maps.
  */
 function mergeMapsInto<
   U extends DeepMergeIntoFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
-  m_target: Reference<Map<unknown, unknown>>,
+  mut_target: Reference<Map<unknown, unknown>>,
   values: ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>,
   utils: U,
   meta: M | undefined,
 ) {
-  const action = utils.mergeFunctions.mergeMaps(m_target, values, utils, meta);
+  const action = utils.mergeFunctions.mergeMaps(mut_target, values, utils, meta);
 
   if (action === actions.defaultMerge) {
-    utils.defaultMergeFunctions.mergeMaps(m_target, values);
+    utils.defaultMergeFunctions.mergeMaps(mut_target, values);
   }
 }
 
 /**
  * Merge other things into a target.
  *
- * @param m_target - The target to merge into.
+ * @param mut_target - The target to merge into.
  * @param values - The other things.
  */
 function mergeOthersInto<
   U extends DeepMergeIntoFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
->(m_target: Reference<unknown>, values: ReadonlyArray<unknown>, utils: U, meta: M | undefined) {
-  const action = utils.mergeFunctions.mergeOthers(m_target, values, utils, meta);
+>(mut_target: Reference<unknown>, values: ReadonlyArray<unknown>, utils: U, meta: M | undefined) {
+  const action = utils.mergeFunctions.mergeOthers(mut_target, values, utils, meta);
 
-  if (action === actions.defaultMerge || m_target.value === actions.defaultMerge) {
-    utils.defaultMergeFunctions.mergeOthers(m_target, values);
+  if (action === actions.defaultMerge || mut_target.value === actions.defaultMerge) {
+    utils.defaultMergeFunctions.mergeOthers(mut_target, values);
   }
 }

src/deepmerge.ts

@@ -136,8 +136,8 @@ export function mergeUnknowns<
   const type = getObjectType(filteredValues[0]);
 
   if (type !== ObjectType.NOT && type !== ObjectType.OTHER) {
-    for (let m_index = 1; m_index < filteredValues.length; m_index++) {
-      if (getObjectType(filteredValues[m_index]) === type) {
+    for (let mut_index = 1; mut_index < filteredValues.length; mut_index++) {
+      if (getObjectType(filteredValues[mut_index]) === type) {
         continue;
       }
 

src/defaults/into.ts

@@ -16,15 +16,15 @@ export type MergeFunctions = {
 /**
  * The default strategy to merge records into a target record.
  *
- * @param m_target - The result will be mutated into this record
+ * @param mut_target - The result will be mutated into this record
  * @param values - The records (including the target's value if there is one).
  */
 function mergeRecordsInto<
   Ts extends ReadonlyArray<Record<PropertyKey, unknown>>,
   U extends DeepMergeIntoFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
->(m_target: Reference<Record<PropertyKey, unknown>>, values: Ts, utils: U, meta: M | undefined): void {
+>(mut_target: Reference<Record<PropertyKey, unknown>>, values: Ts, utils: U, meta: M | undefined): void {
   for (const key of getKeys(values)) {
     const propValues = [];
 
@@ -47,66 +47,66 @@ function mergeRecordsInto<
     mergeUnknownsInto<ReadonlyArray<unknown>, U, M, MM>(propertyTarget, propValues, utils, updatedMeta);
 
     if (key === "__proto__") {
-      Object.defineProperty(m_target.value, key, {
+      Object.defineProperty(mut_target.value, key, {
         value: propertyTarget.value,
         configurable: true,
         enumerable: true,
         writable: true,
       });
     } else {
-      m_target.value[key] = propertyTarget.value;
+      mut_target.value[key] = propertyTarget.value;
     }
   }
 }
 
 /**
  * The default strategy to merge arrays into a target array.
  *
- * @param m_target - The result will be mutated into this array
+ * @param mut_target - The result will be mutated into this array
  * @param values - The arrays (including the target's value if there is one).
  */
 function mergeArraysInto<Ts extends ReadonlyArray<ReadonlyArray<unknown>>>(
-  m_target: Reference<unknown[]>,
+  mut_target: Reference<unknown[]>,
   values: Ts,
 ): void {
-  m_target.value.push(...values.slice(1).flat());
+  mut_target.value.push(...values.slice(1).flat());
 }
 
 /**
  * The default strategy to merge sets into a target set.
  *
- * @param m_target - The result will be mutated into this set
+ * @param mut_target - The result will be mutated into this set
  * @param values - The sets (including the target's value if there is one).
  */
 function mergeSetsInto<Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>>(
-  m_target: Reference<Set<unknown>>,
+  mut_target: Reference<Set<unknown>>,
   values: Ts,
 ): void {
   for (const value of getIterableOfIterables(values.slice(1))) {
-    m_target.value.add(value);
+    mut_target.value.add(value);
   }
 }
 
 /**
  * The default strategy to merge maps into a target map.
  *
- * @param m_target - The result will be mutated into this map
+ * @param mut_target - The result will be mutated into this map
  * @param values - The maps (including the target's value if there is one).
  */
 function mergeMapsInto<Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>>(
-  m_target: Reference<Map<unknown, unknown>>,
+  mut_target: Reference<Map<unknown, unknown>>,
   values: Ts,
 ): void {
   for (const [key, value] of getIterableOfIterables(values.slice(1))) {
-    m_target.value.set(key, value);
+    mut_target.value.set(key, value);
   }
 }
 
 /**
  * Set the target to the last value.
  */
-function mergeOthersInto<Ts extends ReadonlyArray<unknown>>(m_target: Reference<unknown>, values: Ts) {
-  m_target.value = values.at(-1);
+function mergeOthersInto<Ts extends ReadonlyArray<unknown>>(mut_target: Reference<unknown>, values: Ts) {
+  mut_target.value = values.at(-1);
 }
 
 /**