diff --git a/docs/deepmergeCustom.md b/docs/deepmergeCustom.md
index c25bd000..fb3c5379 100644
--- a/docs/deepmergeCustom.md
+++ b/docs/deepmergeCustom.md
@@ -170,7 +170,7 @@ declaring a module block for this library and defining the same interface.
 declare module "deepmerge-ts" {
   interface DeepMergeFunctionURItoKind<
     Ts extends ReadonlyArray<unknown>,
-    MF extends DeepMergeFunctionsURIs,
+    Fs extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly MyCustomMergeURI: MyValue;
@@ -215,7 +215,7 @@ customDeepmerge(x, y, z); // => { foo: [Date, Date, Date] }
 declare module "deepmerge-ts" {
   interface DeepMergeFunctionURItoKind<
     Ts extends ReadonlyArray<unknown>,
-    MF extends DeepMergeFunctionsURIs,
+    Fs extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly MyDeepMergeDatesURI: EveryIsDate<Ts> extends true
@@ -301,7 +301,7 @@ customizedDeepmerge(x, y, z); // => { key1: { subkey1: `one`, subkey2: `two` } }
 declare module "deepmerge-ts" {
   interface DeepMergeFunctionURItoKind<
     Ts extends Readonly<ReadonlyArray<unknown>>,
-    MF extends DeepMergeFunctionsURIs,
+    Fs extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly FilterNullValues: FilterOut<Ts, null>;
@@ -433,7 +433,7 @@ customizedDeepmerge(x, y); // => { foo: { bar: { baz: "special merge", bar: { ba
 declare module "deepmerge-ts" {
   interface DeepMergeFunctionURItoKind<
     Ts extends Readonly<ReadonlyArray<unknown>>,
-    MF extends DeepMergeFunctionsURIs,
+    Fs extends DeepMergeFunctionsURIs,
     M, // This is the meta data type
   > {
     readonly KeyPathBasedMerge: Ts[number] extends number
diff --git a/src/deepmerge.ts b/src/deepmerge.ts
index adf24efb..6c816d46 100644
--- a/src/deepmerge.ts
+++ b/src/deepmerge.ts
@@ -150,19 +150,19 @@ function getUtils<
 export function mergeUnknowns<
   Ts extends ReadonlyArray<unknown>,
   U extends DeepMergeFunctionUtils<M, MM>,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
->(values: Ts, utils: U, meta: M | undefined): DeepMergeHKT<Ts, MF, M> {
+>(values: Ts, utils: U, meta: M | undefined): DeepMergeHKT<Ts, Fs, M> {
   const filteredValues = utils.filterValues?.(values, meta) ?? values;
 
   if (filteredValues.length === 0) {
-    return undefined as DeepMergeHKT<Ts, MF, M>;
+    return undefined as DeepMergeHKT<Ts, Fs, M>;
   }
   if (filteredValues.length === 1) {
     return mergeOthers<U, M, MM>(filteredValues, utils, meta) as DeepMergeHKT<
       Ts,
-      MF,
+      Fs,
       M
     >;
   }
@@ -177,7 +177,7 @@ export function mergeUnknowns<
 
       return mergeOthers<U, M, MM>(filteredValues, utils, meta) as DeepMergeHKT<
         Ts,
-        MF,
+        Fs,
         M
       >;
     }
@@ -185,11 +185,11 @@ export function mergeUnknowns<
 
   switch (type) {
     case ObjectType.RECORD: {
-      return mergeRecords<U, MF, M, MM>(
+      return mergeRecords<U, Fs, M, MM>(
         filteredValues as ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>,
         utils,
         meta,
-      ) as DeepMergeHKT<Ts, MF, M>;
+      ) as DeepMergeHKT<Ts, Fs, M>;
     }
 
     case ObjectType.ARRAY: {
@@ -197,7 +197,7 @@ export function mergeUnknowns<
         filteredValues as ReadonlyArray<Readonly<ReadonlyArray<unknown>>>,
         utils,
         meta,
-      ) as DeepMergeHKT<Ts, MF, M>;
+      ) as DeepMergeHKT<Ts, Fs, M>;
     }
 
     case ObjectType.SET: {
@@ -205,7 +205,7 @@ export function mergeUnknowns<
         filteredValues as ReadonlyArray<Readonly<ReadonlySet<unknown>>>,
         utils,
         meta,
-      ) as DeepMergeHKT<Ts, MF, M>;
+      ) as DeepMergeHKT<Ts, Fs, M>;
     }
 
     case ObjectType.MAP: {
@@ -215,13 +215,13 @@ export function mergeUnknowns<
         >,
         utils,
         meta,
-      ) as DeepMergeHKT<Ts, MF, M>;
+      ) as DeepMergeHKT<Ts, Fs, M>;
     }
 
     default: {
       return mergeOthers<U, M, MM>(filteredValues, utils, meta) as DeepMergeHKT<
         Ts,
-        MF,
+        Fs,
         M
       >;
     }
@@ -235,7 +235,7 @@ export function mergeUnknowns<
  */
 function mergeRecords<
   U extends DeepMergeFunctionUtils<M, MM>,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -255,7 +255,7 @@ function mergeRecords<
     return utils.defaultMergeFunctions.mergeRecords<
       ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>,
       U,
-      MF,
+      Fs,
       M,
       MM
     >(values, utils, meta);
diff --git a/src/defaults/vanilla.ts b/src/defaults/vanilla.ts
index 4bede882..f2276260 100644
--- a/src/defaults/vanilla.ts
+++ b/src/defaults/vanilla.ts
@@ -30,14 +30,14 @@ export type MergeFunctions = {
 export function mergeRecords<
   Ts extends ReadonlyArray<Record<PropertyKey, unknown>>,
   U extends DeepMergeFunctionUtils<M, MM>,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
   values: Ts,
   utils: U,
   meta: M | undefined,
-): DeepMergeRecordsDefaultHKT<Ts, MF, M> {
+): DeepMergeRecordsDefaultHKT<Ts, Fs, M> {
   const result: Record<PropertyKey, unknown> = {};
 
   for (const key of getKeys(values)) {
@@ -58,7 +58,7 @@ export function mergeRecords<
       parents: values,
     } as unknown as MM);
 
-    const propertyResult = mergeUnknowns<ReadonlyArray<unknown>, U, MF, M, MM>(
+    const propertyResult = mergeUnknowns<ReadonlyArray<unknown>, U, Fs, M, MM>(
       propValues,
       utils,
       updatedMeta,
@@ -80,7 +80,7 @@ export function mergeRecords<
     }
   }
 
-  return result as DeepMergeRecordsDefaultHKT<Ts, MF, M>;
+  return result as DeepMergeRecordsDefaultHKT<Ts, Fs, M>;
 }
 
 /**
@@ -90,10 +90,10 @@ export function mergeRecords<
  */
 export function mergeArrays<
   Ts extends ReadonlyArray<ReadonlyArray<unknown>>,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
->(values: Ts): DeepMergeArraysDefaultHKT<Ts, MF, M> {
-  return values.flat() as DeepMergeArraysDefaultHKT<Ts, MF, M>;
+>(values: Ts): DeepMergeArraysDefaultHKT<Ts, Fs, M> {
+  return values.flat() as DeepMergeArraysDefaultHKT<Ts, Fs, M>;
 }
 
 /**
diff --git a/src/types/defaults.ts b/src/types/defaults.ts
index 5ad6433a..be410846 100644
--- a/src/types/defaults.ts
+++ b/src/types/defaults.ts
@@ -95,12 +95,12 @@ type RecordToRecordMeta<T extends Record<PropertyKey, unknown>> =
  */
 export type DeepMergeRecordsDefaultHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
 > =
   Ts extends ReadonlyArray<Record<PropertyKey, unknown>>
     ? SimplifyObject<
-        DeepMergeRecordMetaDefaultHKTProps<RecordsToRecordMeta<Ts>, MF, M>
+        DeepMergeRecordMetaDefaultHKTProps<RecordsToRecordMeta<Ts>, Fs, M>
       >
     : never;
 
@@ -109,11 +109,11 @@ export type DeepMergeRecordsDefaultHKT<
  */
 type DeepMergeRecordMetaDefaultHKTProps<
   RecordMetas,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
 > =
   RecordMetas extends ReadonlyArray<RecordMeta>
-    ? CreateRecordFromMeta<MergeRecordMeta<RecordMetas>, MF, M>
+    ? CreateRecordFromMeta<MergeRecordMeta<RecordMetas>, Fs, M>
     : never;
 
 type MergeRecordMeta<RecordMetas extends ReadonlyArray<RecordMeta>> =
@@ -143,7 +143,7 @@ type GroupValuesByKey<Ts> = Ts extends readonly [
     }
   : never;
 
-type CreateRecordFromMeta<Ts, MF extends DeepMergeFunctionsURIs, M> =
+type CreateRecordFromMeta<Ts, Fs extends DeepMergeFunctionsURIs, M> =
   Ts extends ReadonlyArray<unknown>
     ? TupleToIntersection<{
         [I in keyof Ts]: Ts[I] extends {
@@ -151,7 +151,7 @@ type CreateRecordFromMeta<Ts, MF extends DeepMergeFunctionsURIs, M> =
           values: infer Values extends ReadonlyArray<unknown>;
           optional: infer O extends boolean;
         }
-          ? CreateRecordForKeyFromMeta<Key, Values, O, MF, M>
+          ? CreateRecordForKeyFromMeta<Key, Values, O, Fs, M>
           : never;
       }>
     : never;
@@ -160,14 +160,14 @@ type CreateRecordForKeyFromMeta<
   Key extends PropertyKey,
   Values extends ReadonlyArray<unknown>,
   Optional extends boolean,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
 > = Optional extends true
   ? {
-      [k in Key]+?: DeepMergeHKT<Values, MF, M>;
+      [k in Key]+?: DeepMergeHKT<Values, Fs, M>;
     }
   : {
-      [k in Key]-?: DeepMergeHKT<Values, MF, M>;
+      [k in Key]-?: DeepMergeHKT<Values, Fs, M>;
     };
 
 /**
@@ -267,16 +267,16 @@ type DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<
  */
 export type DeepMergeArraysDefaultHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
-> = DeepMergeArraysDefaultHKTHelper<Ts, MF, M, []>;
+> = DeepMergeArraysDefaultHKTHelper<Ts, Fs, M, []>;
 
 /**
  * Tail-recursive helper type for DeepMergeArraysDefaultHKT.
  */
 type DeepMergeArraysDefaultHKTHelper<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
   Acc extends ReadonlyArray<unknown>,
 > = Ts extends readonly [
@@ -287,7 +287,7 @@ type DeepMergeArraysDefaultHKTHelper<
       ReadonlyArray<unknown>,
       ...ReadonlyArray<ReadonlyArray<unknown>>,
     ]
-    ? DeepMergeArraysDefaultHKTHelper<Rest, MF, M, [...Acc, ...Head]>
+    ? DeepMergeArraysDefaultHKTHelper<Rest, Fs, M, [...Acc, ...Head]>
     : [...Acc, ...Head]
   : never;
 
diff --git a/src/types/merging.ts b/src/types/merging.ts
index 4aab0c6c..3e8f6c98 100644
--- a/src/types/merging.ts
+++ b/src/types/merging.ts
@@ -20,12 +20,12 @@ import {
 // eslint-disable-next-line ts/consistent-type-definitions
 export interface DeepMergeFunctionURItoKind<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   in out M,
 > {
   readonly DeepMergeLeafURI: DeepMergeLeaf<Ts>;
-  readonly DeepMergeRecordsDefaultURI: DeepMergeRecordsDefaultHKT<Ts, MF, M>;
-  readonly DeepMergeArraysDefaultURI: DeepMergeArraysDefaultHKT<Ts, MF, M>;
+  readonly DeepMergeRecordsDefaultURI: DeepMergeRecordsDefaultHKT<Ts, Fs, M>;
+  readonly DeepMergeArraysDefaultURI: DeepMergeArraysDefaultHKT<Ts, Fs, M>;
   readonly DeepMergeSetsDefaultURI: DeepMergeSetsDefaultHKT<Ts>;
   readonly DeepMergeMapsDefaultURI: DeepMergeMapsDefaultHKT<Ts>;
   readonly DeepMergeFilterValuesDefaultURI: DeepMergeFilterValuesDefaultHKT<Ts>;
@@ -38,9 +38,9 @@ export interface DeepMergeFunctionURItoKind<
 type DeepMergeFunctionKind<
   URI extends DeepMergeFunctionURIs,
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
-> = DeepMergeFunctionURItoKind<Ts, MF, M>[URI];
+> = DeepMergeFunctionURItoKind<Ts, Fs, M>[URI];
 
 /**
  * A union of all valid merge function URIs.
@@ -91,16 +91,16 @@ export type DeepMergeFunctionsURIs = Readonly<{
  */
 export type DeepMergeHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
 > =
   IsTuple<Ts> extends true
     ? Ts extends readonly []
       ? undefined
-      : DeepMergeHKTHelper<FilterValuesHKT<Ts, MF, M>, MF, M>
+      : DeepMergeHKTHelper<FilterValuesHKT<Ts, Fs, M>, Fs, M>
     : unknown;
 
-type DeepMergeHKTHelper<Ts, MF extends DeepMergeFunctionsURIs, M> =
+type DeepMergeHKTHelper<Ts, Fs extends DeepMergeFunctionsURIs, M> =
   Ts extends ReadonlyArray<unknown>
     ? IsTuple<Ts> extends true
       ? Ts extends readonly []
@@ -108,14 +108,14 @@ type DeepMergeHKTHelper<Ts, MF extends DeepMergeFunctionsURIs, M> =
         : Ts extends readonly [infer T1]
           ? T1
           : EveryIsArray<Ts> extends true
-            ? DeepMergeArraysHKT<Ts, MF, M>
+            ? DeepMergeArraysHKT<Ts, Fs, M>
             : EveryIsMap<Ts> extends true
-              ? DeepMergeMapsHKT<Ts, MF, M>
+              ? DeepMergeMapsHKT<Ts, Fs, M>
               : EveryIsSet<Ts> extends true
-                ? DeepMergeSetsHKT<Ts, MF, M>
+                ? DeepMergeSetsHKT<Ts, Fs, M>
                 : EveryIsRecord<Ts> extends true
-                  ? DeepMergeRecordsHKT<Ts, MF, M>
-                  : DeepMergeOthersHKT<Ts, MF, M>
+                  ? DeepMergeRecordsHKT<Ts, Fs, M>
+                  : DeepMergeOthersHKT<Ts, Fs, M>
       : unknown
     : never;
 
@@ -124,54 +124,54 @@ type DeepMergeHKTHelper<Ts, MF extends DeepMergeFunctionsURIs, M> =
  */
 type DeepMergeRecordsHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
-> = DeepMergeFunctionKind<MF["DeepMergeRecordsURI"], Ts, MF, M>;
+> = DeepMergeFunctionKind<Fs["DeepMergeRecordsURI"], Ts, Fs, M>;
 
 /**
  * Deep merge arrays.
  */
 type DeepMergeArraysHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
-> = DeepMergeFunctionKind<MF["DeepMergeArraysURI"], Ts, MF, M>;
+> = DeepMergeFunctionKind<Fs["DeepMergeArraysURI"], Ts, Fs, M>;
 
 /**
  * Deep merge sets.
  */
 type DeepMergeSetsHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
-> = DeepMergeFunctionKind<MF["DeepMergeSetsURI"], Ts, MF, M>;
+> = DeepMergeFunctionKind<Fs["DeepMergeSetsURI"], Ts, Fs, M>;
 
 /**
  * Deep merge maps.
  */
 type DeepMergeMapsHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
-> = DeepMergeFunctionKind<MF["DeepMergeMapsURI"], Ts, MF, M>;
+> = DeepMergeFunctionKind<Fs["DeepMergeMapsURI"], Ts, Fs, M>;
 
 /**
  * Deep merge other things.
  */
 type DeepMergeOthersHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
-> = DeepMergeFunctionKind<MF["DeepMergeOthersURI"], Ts, MF, M>;
+> = DeepMergeFunctionKind<Fs["DeepMergeOthersURI"], Ts, Fs, M>;
 
 /**
  * Filter values.
  */
 type FilterValuesHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
-> = DeepMergeFunctionKind<MF["DeepMergeFilterValuesURI"], Ts, MF, M>;
+> = DeepMergeFunctionKind<Fs["DeepMergeFilterValuesURI"], Ts, Fs, M>;
 
 /**
  * The merge function that returns a leaf.
diff --git a/tests/deepmerge-custom.test.ts b/tests/deepmerge-custom.test.ts
index d312de79..22fbef26 100644
--- a/tests/deepmerge-custom.test.ts
+++ b/tests/deepmerge-custom.test.ts
@@ -17,7 +17,7 @@ import { areAllNumbers, hasProp } from "./utils";
 declare module "../src/types" {
   interface DeepMergeFunctionURItoKind<
     Ts extends ReadonlyArray<unknown>,
-    MF extends DeepMergeFunctionsURIs,
+    Fs extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly CustomArrays1: string[];
@@ -27,7 +27,7 @@ declare module "../src/types" {
 declare module "../src/types" {
   interface DeepMergeFunctionURItoKind<
     Ts extends ReadonlyArray<unknown>,
-    MF extends DeepMergeFunctionsURIs,
+    Fs extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly CustomArrays2: Ts extends Readonly<
@@ -42,10 +42,10 @@ declare module "../src/types" {
 declare module "../src/types" {
   interface DeepMergeFunctionURItoKind<
     Ts extends ReadonlyArray<unknown>,
-    MF extends DeepMergeFunctionsURIs,
+    Fs extends DeepMergeFunctionsURIs,
     M,
   > {
-    readonly CustomRecords3: Entries<DeepMergeRecordsDefaultHKT<Ts, MF, M>>;
+    readonly CustomRecords3: Entries<DeepMergeRecordsDefaultHKT<Ts, Fs, M>>;
   }
 }
 
@@ -58,7 +58,7 @@ type Entries<T> = Array<
 declare module "../src/types" {
   interface DeepMergeFunctionURItoKind<
     Ts extends ReadonlyArray<unknown>,
-    MF extends DeepMergeFunctionsURIs,
+    Fs extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly NoArrayMerge1: DeepMergeLeaf<Ts>;
@@ -68,7 +68,7 @@ declare module "../src/types" {
 declare module "../src/types" {
   interface DeepMergeFunctionURItoKind<
     Ts extends ReadonlyArray<unknown>,
-    MF extends DeepMergeFunctionsURIs,
+    Fs extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly MergeDates1: EveryIsDate<Ts> extends true ? Ts : DeepMergeLeaf<Ts>;
@@ -85,7 +85,7 @@ type EveryIsDate<Ts extends ReadonlyArray<unknown>> =
 declare module "../src/types" {
   interface DeepMergeFunctionURItoKind<
     Ts extends Readonly<ReadonlyArray<unknown>>,
-    MF extends DeepMergeFunctionsURIs,
+    Fs extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly KeyPathBasedMerge: Ts[number] extends number
@@ -97,7 +97,7 @@ declare module "../src/types" {
 declare module "../src/types" {
   interface DeepMergeFunctionURItoKind<
     Ts extends ReadonlyArray<unknown>,
-    MF extends DeepMergeFunctionsURIs,
+    Fs extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly CustomOthers3: Ts[number] extends object
@@ -107,7 +107,7 @@ declare module "../src/types" {
               [J in keyof Ts[I]]: Ts[I][J];
             };
           },
-          MF,
+          Fs,
           M
         >
       : DeepMergeLeaf<Ts>;
@@ -117,7 +117,7 @@ declare module "../src/types" {
 declare module "../src/types" {
   interface DeepMergeFunctionURItoKind<
     Ts extends ReadonlyArray<unknown>,
-    MF extends DeepMergeFunctionsURIs,
+    Fs extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly CustomFilterValues1: FilterOut<Ts, null>;