diff --git a/src/lib/_internal/arrayFns.ts b/src/lib/_internal/arrayFns.ts
new file mode 100644
index 0000000..7d85f9d
--- /dev/null
+++ b/src/lib/_internal/arrayFns.ts
@@ -0,0 +1,33 @@
+import { Mutable } from '../types';
+
+type ArrayFnNames = keyof ArrayFns<any>;
+
+const arrayFns: Set<ArrayFnNames> = new Set(['every', 'some', 'sort', 'map', 'filter', 'reduce', 'reduceRight']);
+
+export function isArrayFn(input: any): input is ArrayFnNames {
+	return arrayFns.has(input);
+}
+
+export type ArrayFns<Values> = {
+	every(
+		...params: Parameters<Array<Values>['every']>
+	): Mutable<ReturnType<Array<Values>['every']>>;
+	some(
+		...params: Parameters<Array<Values>['some']>
+	): Mutable<ReturnType<Array<Values>['some']>>;
+	sort(
+		...params: Parameters<Array<Values>['sort']>
+	): Mutable<ReturnType<Array<Values>['sort']>>;
+	map(
+		...params: Parameters<Array<Values>['map']>
+	): Mutable<ReturnType<Array<Values>['map']>>;
+	filter(
+		...params: Parameters<Array<Values>['filter']>
+	): Mutable<ReturnType<Array<Values>['filter']>>;
+	reduce(
+		...params: Parameters<Array<Values>['reduce']>
+	): Mutable<ReturnType<Array<Values>['reduce']>>;
+	reduceRight(
+		...params: Parameters<Array<Values>['reduceRight']>
+	): Mutable<ReturnType<Array<Values>['reduceRight']>>;
+};
diff --git a/src/lib/_internal/objectFns.ts b/src/lib/_internal/objectFns.ts
new file mode 100644
index 0000000..eac8690
--- /dev/null
+++ b/src/lib/_internal/objectFns.ts
@@ -0,0 +1,15 @@
+import { Mutable } from '../types';
+
+type ObjectFnNames = keyof ObjectFns<any>;
+
+const objectFns: Set<ObjectFnNames> = new Set(['keys', 'values', 'entries']);
+
+export function isObjectFn(input: any): input is ObjectFnNames {
+	return objectFns.has(input);
+}
+
+export type ObjectFns<Values> = {
+	keys(): Mutable<string[]>;
+	values(): Mutable<Values[]>;
+	entries(): Mutable<[string, Values][]>;
+};
diff --git a/src/lib/mutable.ts b/src/lib/mutable.ts
index 54538c1..53f8ee6 100644
--- a/src/lib/mutable.ts
+++ b/src/lib/mutable.ts
@@ -1,18 +1,26 @@
 import { Mutable } from './types';
-import isRegularObject from './utils/isRegularObject';
 import eventBus from './eventBus';
+import mutableFn from './mutableFn';
+import { isArrayFn } from './_internal/arrayFns';
+import { isObjectFn } from './_internal/objectFns';
 
 export function mutable<Value extends any>(initialValue?: Value) {
 	const events = eventBus();
 
+	const isMutableObject = isMutableObjectValue(initialValue);
+	const valueType = isMutableObjectValue(initialValue)
+		? Array.isArray(initialValue)
+			? 'array'
+			: 'object'
+		: 'primitive';
+
 	const obj = new Proxy(
 		{
-			value:
-				isRegularObject(initialValue) || Array.isArray(initialValue)
-					? mutableObject(initialValue, (newVal, oldVal) =>
-							events.change(newVal, oldVal),
-					  )
-					: initialValue,
+			value: isMutableObject
+				? mutableObject(initialValue, (newVal, oldVal) =>
+						events.change(newVal, oldVal),
+				  )
+				: initialValue,
 		},
 		{
 			get(target, prop) {
@@ -24,6 +32,22 @@ export function mutable<Value extends any>(initialValue?: Value) {
 							events.changeHandler(callback);
 						};
 					default:
+						if (valueType === 'array') {
+							if (isArrayFn(prop)) {
+								return (callback: any) =>
+									mutableFn((data) => data[prop](callback))(
+										obj,
+									);
+							}
+						} else if (valueType === 'object') {
+							if (isObjectFn(prop)) {
+								return () =>
+									mutableFn((data) => Object[prop](data))(
+										obj,
+									);
+							}
+						}
+
 						return target.value;
 				}
 			},
@@ -43,7 +67,7 @@ export function mutable<Value extends any>(initialValue?: Value) {
 	return obj as Mutable<Value>;
 }
 
-function mutableObject<Obj extends object | unknown[]>(
+function mutableObject<Obj extends Record<string, unknown> | unknown[]>(
 	initialValue: Obj,
 	onChange: (newVal: Obj, oldVal: null) => void,
 ): Obj {
@@ -98,4 +122,17 @@ function mutableObject<Obj extends object | unknown[]>(
 	return proxy;
 }
 
+function isMutableObjectValue(
+	input: unknown,
+): input is Record<string, unknown> | unknown[] {
+	return (
+		typeof input === 'object' &&
+		!!input &&
+		(('constructor' in input &&
+			input.constructor === Object &&
+			Object.getPrototypeOf(input) === Object.prototype) ||
+			Array.isArray(input))
+	);
+}
+
 export default mutable;
diff --git a/src/lib/types.ts b/src/lib/types.ts
index a86f7b2..775a7f0 100644
--- a/src/lib/types.ts
+++ b/src/lib/types.ts
@@ -1,9 +1,15 @@
 import { MutationCallback } from './eventBus';
+import { ArrayFns } from './_internal/arrayFns';
+import { ObjectFns } from './_internal/objectFns';
 
 export type Mutable<Value> = {
 	readonly _mutable: true;
 	readonly onChange: (callback: MutationCallback<Value>) => void;
 	value: Value;
-};
+} & (Value extends (infer T)[]
+	? ArrayFns<T>
+	: Value extends Record<string, infer T>
+	? ObjectFns<T>
+	: Record<string, never>);
 
 export type MaybeMutable<Value> = Value | Mutable<Value>;
diff --git a/src/lib/utils/isRegularObject.ts b/src/lib/utils/isRegularObject.ts
deleted file mode 100644
index 6c225e4..0000000
--- a/src/lib/utils/isRegularObject.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-function isRegularObject(input: unknown): input is object {
-	return (
-		typeof input === 'object' &&
-		!!input &&
-		'constructor' in input &&
-		input.constructor === Object &&
-		Object.getPrototypeOf(input) === Object.prototype
-	);
-}
-
-export default isRegularObject;
