diff --git a/src/index.d.ts b/src/index.d.ts
index 45bb98e..08d4963 100644
--- a/src/index.d.ts
+++ b/src/index.d.ts
@@ -4,6 +4,11 @@ import {
   OutputSelector,
   OutputParametricSelector
 } from "reselect";
+import {
+  Iterable,
+  List
+} from "immutable";
+
 
 export as namespace ReselectMap;
 
@@ -20,6 +25,33 @@ export const objectMemoize: MemoizeFunc;
 export const listMemoize: MemoizeFunc;
 export const mapMemoize: MemoizeFunc;
 
+export function createMappedSelectorCreator(
+  memoizeFunc: MemoizeFunc,
+  equalityCheck?: <T>(a: T, b: T) => boolean
+): typeof createArraySelector;
+
+type ArrayMapper<V> = (arr: Array<V>, callback: (value: V) => V) => Array<V>;
+type ImmutableListMapper<V> = (list: List<V>, callback: (value: V) => V) => List<V>;
+
+export type MemoizeListOptions<V> = {
+  mapper: ArrayMapper<V> | ImmutableListMapper<V>;
+  equalityCheck: <T>(a: T, b: T) => boolean;
+  unique?: boolean;
+};
+export function memoizeList<F extends Function, V>(fn: F, memoizeOptions: MemoizeListOptions<V>): F;
+
+type ArrayWithIndexMapper<V> = (arr: Array<V>, callback: (key: number, value: V) => V) => Array<V>;
+type ObjectMapper<K extends keyof any, V> = (record: Record<K, V>, callback: (key: K, value: V) => V) => Record<K, V>;
+type ImmutableIterableMapper<K, V> = (arr: Iterable<K, V>, callback: (key: K, value: V) => V) => Iterable<K, V>;
+
+export type MemoizeMapOptions<K extends keyof any, V> = {
+  mapper: ArrayWithIndexMapper<V> | ObjectMapper<K, V> | ImmutableIterableMapper<K, V>;
+  equalityCheck: <T>(a: T, b: T) => boolean;
+  unique?: boolean | true;
+};
+
+export function memoizeMap<F extends Function, K extends keyof any, V>(fn: F, memoizeOptions: MemoizeMapOptions<K, V>): F;
+
 export function createArraySelectorCreator(
   equalityCheck: <T>(a: T, b: T) => boolean
 ): typeof createArraySelector;
diff --git a/src/index.js b/src/index.js
index d521564..16afca5 100644
--- a/src/index.js
+++ b/src/index.js
@@ -57,7 +57,7 @@ export const mapMemoize = (fn, equalityCheck) =>
 // wrapping the result func and defaultMemoize for wrapping the selector. It
 // sucks that we're relying on an implementation detail but I'll be back to fix
 // this code again whenever it breaks :)
-function createMappedSelectorCreator(memoize, ...memoizeOptions) {
+export function createMappedSelectorCreator(memoize, ...memoizeOptions) {
   return createSelectorCreator((fn, mapmem) => {
     if (mapmem === true) {
       return memoize(fn, ...memoizeOptions);
@@ -80,3 +80,5 @@ export const createListSelectorCreator = equalityCheck =>
   createMappedSelectorCreator(listMemoize, equalityCheck);
 export const createMapSelectorCreator = equalityCheck =>
   createMappedSelectorCreator(mapMemoize, equalityCheck);
+
+export { memoizeMap, memoizeList };
diff --git a/typescript_test/test.ts b/typescript_test/test.ts
index 9bf8fd4..17ef32c 100644
--- a/typescript_test/test.ts
+++ b/typescript_test/test.ts
@@ -1,7 +1,9 @@
 import {
   createArraySelector,
   createObjectSelector,
-  createArraySelectorCreator
+  createArraySelectorCreator,
+  createMappedSelectorCreator,
+  memoizeMap
 } from "../src/index";
 
 function testArraySelector() {
@@ -75,3 +77,17 @@ function testArraySelectorCreator() {
 
   const foo: number[] = selector({ items: [1, 2, 3], mul: 5 });
 }
+
+const arrayWithIndexMemoize = <F extends Function, T> (fn: F, equalityCheck: <T>(a: T, b: T) => boolean) =>
+  memoizeMap(fn, {
+    equalityCheck,
+    mapper: (arr: Array<T>, callback: (key: number, value: T) => T) => {
+      const result = [];
+      for (let i = 0; i < arr.length; i++) {
+        result[i] = callback(i, arr[i]);
+      }
+      return result;
+    }
+  });
+
+createMappedSelectorCreator(arrayWithIndexMemoize);