Add .decorator() method

index.d.ts

@@ -95,6 +95,37 @@ declare const mem: {
 		options?: mem.Options<ArgumentsType, CacheKeyType, ReturnType>
 	): FunctionToMemoize;
 
+	/**
+	Returns a decorator which memoizes the function provided.
+
+	@example
+	```
+	const mem = require('mem');
+
+	class Example {
+		constructor() {
+			this.i = 0;
+		}
+
+		@mem.mixin();
+		counter() {
+			return ++this.i;
+		}
+	}
+	```
+	*/
+	mixin<ArgumentsType extends unknown[],
+		ReturnType,
+		CacheKeyType,
+		FunctionToMemoize = (...arguments: ArgumentsType) => ReturnType
+	>(
+		options?: mem.Options<ArgumentsType, CacheKeyType, ReturnType>
+	): (
+		target: FunctionToMemoize,
+		propertyKey: string,
+		descriptor: PropertyDescriptor
+	) => FunctionToMemoize;
+
 	/**
 	Clear all cached data of a memoized function.
 

index.js

@@ -44,6 +44,16 @@ const mem = (fn, {
 
 module.exports = mem;
 
+module.exports.mixin = options => (target, propertyKey, descriptor) => {
+	if (typeof target !== 'function') {
+		throw new TypeError('`target` must be a function');
+	}
+
+	descriptor.value = mem(target[propertyKey], options);
+
+	return target;
+};
+
 module.exports.clear = fn => {
 	if (!cacheStore.has(fn)) {
 		throw new Error('Can\'t clear a function that was not memoized!');

readme.md

@@ -196,6 +196,31 @@ Use a different cache storage. Must implement the following methods: `.has(key)`
 
 Refer to the [caching strategies](#caching-strategy) section for more information.
 
+### mem.mixin(options)
+
+Returns a decorator which memoizes the function provided.
+
+#### options
+
+Type: `object`
+
+Same as options for `mem()`.
+
+```js
+const mem = require('mem');
+
+class Example {
+	constructor() {
+		this.i = 0;
+	}
+
+	@mem.mixin();
+	counter() {
+		return ++this.i;
+	}
+}
+```
+
 ### mem.clear(fn)
 
 Clear all cached data of a memoized function.

test.js

@@ -163,6 +163,22 @@ test('preserves the original function name', t => {
 	t.is(mem(function foo() {}).name, 'foo'); // eslint-disable-line func-names
 });
 
+test('.mixin()', t => {
+	class TestClass {
+		constructor() {
+			this.i = 0;
+		}
+
+		counter() {
+			return ++this.i;
+		}
+	}
+
+	mem.mixin()(TestClass.prototype.counter, 'counter', TestClass.prototype);
+
+	t.is(new TestClass().counter(), 1);
+});
+
 test('.clear()', t => {
 	let i = 0;
 	const fixture = () => i++;
@@ -194,6 +210,6 @@ test('prototype support', t => {
 
 test('mem.clear() throws when called with a plain function', t => {
 	t.throws(() => {
-		mem.clear(() => {});
+		mem.clear(() => { });
 	}, 'Can\'t clear a function that was not memoized!');
 });