diff --git a/lib/array.js b/lib/array.js
index 118e3818..9334f659 100644
--- a/lib/array.js
+++ b/lib/array.js
@@ -2,6 +2,20 @@
 
 const common = require('@metarhia/common');
 
+const copy = name => {
+  switch (name) {
+    case 'Set':
+      return new Set();
+    case 'Map':
+      return new Map();
+    case 'Array':
+      return [];
+    case 'String':
+      return '';
+  }
+  return null;
+};
+
 // Asynchronous map (iterate parallel)
 //   items - <Array>, incoming
 //   fn - <Function>, to be executed for each value in the array
@@ -12,31 +26,47 @@ const common = require('@metarhia/common');
 //   done - <Function>, on done, optional
 //     err - <Error> | <null>
 //     result - <Array>
-const map = (items, fn, done) => {
+const map = (
+  // Asynchronous map (iterate parallel)
+  items, // array, incoming
+  fn, // function, (current, callback) => callback(err, value)
+  //   to be executed for each value in the array
+  //   current - current element being processed in the array
+  //   callback - function(err, value)
+  done // function (optional), on done callback function(err, result)
+) => {
   done = done || common.emptyness;
-  const len = items.length;
+  const len = items.length || items.size;
+  const name = items.constructor.name;
+  let result = copy(name);
   if (!len) {
-    done(null, []);
+    done(null, result);
     return;
   }
   let errored = false;
   let count = 0;
-  const result = new Array(len);
+  const data = items[Symbol.iterator]();
 
-  const next = (index, err, value) => {
+  const next = (err, value) => {
     if (errored) return;
     if (err) {
       errored = true;
       done(err);
       return;
     }
-    result[index] = value;
+    if (name === 'Array') result.push(value);
+    else if (name === 'Set') result.add(value);
+    else if (name === 'Map') result.set(value[0], value[1]);
+    else result += value;
     count++;
     if (count === len) done(null, result);
   };
 
-  for (let i = 0; i < len; i++) {
-    fn(items[i], next.bind(null, i));
+  let i = 0;
+  while (i < len) {
+    const item = data.next();
+    fn(item.value, next);
+    i++;
   }
 };
 
@@ -59,8 +89,13 @@ const asyncMap = (items, fn, options = {}, done) => {
     options = DEFAULT_OPTIONS;
   }
 
-  if (!items.length) {
-    if (done) done(null, []);
+  const len = items.length || items.size;
+  const name = items.constructor.name;
+  let result = done ? copy(name) : null;
+  const data = items[Symbol.iterator]();
+
+  if (!len) {
+    if (done) done(null, result);
     return;
   }
 
@@ -71,7 +106,6 @@ const asyncMap = (items, fn, options = {}, done) => {
   let sum = 0;
   let count = 0;
 
-  const result = done ? new Array(items.length) : null;
   const ratio = percent / (1 - percent);
 
   const countNumber = () => {
@@ -83,16 +117,21 @@ const asyncMap = (items, fn, options = {}, done) => {
 
   const next = () => {
     const itemsNumber = count ? countNumber() : min;
-    const iterMax = Math.min(items.length, itemsNumber + count);
+    const iterMax = Math.min(len, itemsNumber + count);
 
     begin = Date.now();
     for (; count < iterMax; count++) {
-      const itemResult = fn(items[count], count);
-      if (done) result[count] = itemResult;
+      const itemResult = fn(data.next().value, count);
+      if (done) {
+        if (name === 'Array') result.push(itemResult);
+        else if (name === 'Set') result.add(itemResult);
+        else if (name === 'Map') result.set(itemResult[0], itemResult[1]);
+        else result += itemResult;
+      }
     }
     sum += Date.now() - begin;
 
-    if (count < items.length) {
+    if (count < len) {
       begin = Date.now();
       setTimeout(next, 0);
     } else if (done) {
@@ -115,39 +154,36 @@ const asyncMap = (items, fn, options = {}, done) => {
 //     result - <Array>
 const filter = (items, fn, done) => {
   done = done || common.emptyness;
-  const len = items.length;
+  const len = items.length || items.size;
+  const data = items[Symbol.iterator]();
+  const name = items.constructor.name;
+  let result = copy(name);
 
   if (!len) {
-    done(null, []);
+    done(null, result);
     return;
   }
 
   let count = 0;
-  let suitable = 0;
-  const data = new Array(len);
-  const rejected = Symbol('rejected');
-
-  const next = (index, err, accepted) => {
-    if (!accepted || err) {
-      data[index] = rejected;
-    } else {
-      data[index] = items[index];
-      suitable++;
+
+  const next = (value, err, accepted) => {
+    if (accepted && !err) {
+      if (name === 'Array') result.push(value);
+      else if (name === 'Set') result.add(value);
+      else if (name === 'Map') result.set(value[0], value[1]);
+      else result += value;
     }
     count++;
     if (count === len) {
-      const result = new Array(suitable);
-      let pos = 0;
-      for (let i = 0; i < len; i++) {
-        const val = data[i];
-        if (val !== rejected) result[pos++] = val;
-      }
       done(null, result);
     }
   };
 
-  for (let i = 0; i < len; i++) {
-    fn(items[i], next.bind(null, i));
+  let i = 0;
+  while (i < len) {
+    const item = data.next();
+    fn(item.value, next.bind(null, item.value));
+    i++;
   }
 };
 
@@ -173,7 +209,8 @@ const REDUCE_EMPTY_ARR =
 //       argument in first iteration
 const reduce = (items, fn, done, initial) => {
   done = done || common.emptyness;
-  const len = items.length;
+  const len = items.length || items.size || 0;
+  items = [...items];
   const hasInitial = typeof initial !== 'undefined';
 
   if (len === 0 && !hasInitial) {
@@ -231,7 +268,8 @@ const REDUCE_RIGHT_EMPTY_ARR =
 //       argument in first iteration
 const reduceRight = (items, fn, done, initial) => {
   done = done || common.emptyness;
-  const len = items.length;
+  const len = items.length || items.size || 0;
+  items = [...items];
   const hasInitial = typeof initial !== 'undefined';
 
   if (len === 0 && !hasInitial) {
@@ -276,10 +314,17 @@ const reduceRight = (items, fn, done, initial) => {
 //   done - <Function>, on done, optional
 //     err - <Error> | <null>
 //     items - <Array>
-const each = (items, fn, done) => {
+const each = (
+  // Asynchronous each (iterate in parallel)
+  items, // array, incoming
+  fn, // function, (value, callback) => callback(err)
+  //   value - item from items array
+  //   callback - callback function(err)
+  done // function (optional), on done callback function(err, items)
+) => {
   done = done || common.emptyness;
-  const len = items.length;
-  if (len === 0) {
+  const len = items.length || items.size;
+  if (!len) {
     done(null, items);
     return;
   }
@@ -297,9 +342,7 @@ const each = (items, fn, done) => {
     if (count === len) done(null);
   };
 
-  for (let i = 0; i < len; i++) {
-    fn(items[i], next);
-  }
+  for (const item of items) fn(item, next);
 };
 
 // Asynchronous series
@@ -311,9 +354,17 @@ const each = (items, fn, done) => {
 //   done - <Function>, on done, optional
 //     err - <Error> | <null>
 //     items - <Array>
-const series = (items, fn, done) => {
+const series = (
+  // Asynchronous series
+  items, // array, incoming
+  fn, // function, (value, callback) => callback(err)
+  //   value - item from items array
+  //   callback - callback (err)
+  done // function (optional), on done callback (err, items)
+) => {
   done = done || common.emptyness;
-  const len = items.length;
+  const len = items.length || items.size;
+  const data = items[Symbol.iterator]();
   let i = -1;
 
   const next = () => {
@@ -322,7 +373,7 @@ const series = (items, fn, done) => {
       done(null, items);
       return;
     }
-    fn(items[i], err => {
+    fn(data.next().value, err => {
       if (err) {
         done(err);
         return;
@@ -345,15 +396,16 @@ const series = (items, fn, done) => {
 //     result - <any>
 const find = (items, fn, done) => {
   done = done || common.emptyness;
-  const len = items.length;
-  if (len === 0) {
+  const len = items.length || items.size;
+  const data = items[Symbol.iterator]();
+  if (!len) {
     done();
     return;
   }
   let finished = false;
   const last = len - 1;
 
-  const next = (index, err, accepted) => {
+  const next = (index, item, err, accepted) => {
     if (finished) return;
     if (err) {
       finished = true;
@@ -362,14 +414,15 @@ const find = (items, fn, done) => {
     }
     if (accepted) {
       finished = true;
-      done(null, items[index]);
+      done(null, item);
       return;
     }
     if (index === last) done(null);
   };
 
   for (let i = 0; i < len; i++) {
-    fn(items[i], next.bind(null, i));
+    const item = data.next().value;
+    fn(item, next.bind(null, i, item));
   }
 };
 
@@ -383,14 +436,21 @@ const find = (items, fn, done) => {
 //   done - <Function>, on done, optional
 //     err - <Error> | <null>
 //     result - <boolean>
-const every = (items, fn, done) => {
+const every = (
+  // Asynchronous every
+  items, // array, incoming
+  fn, // function, (value, callback) => callback(err, fits)
+  //   value - item from items array
+  //   callback - callback function(err, fits)
+  done // function, optional on done callback function(err, result)
+) => {
   done = done || common.emptyness;
-  if (items.length === 0) {
+  const len = items.length || items.size;
+  if (!len) {
     done(null, true);
     return;
   }
   let proceedItemsCount = 0;
-  const len = items.length;
 
   const finish = (err, accepted) => {
     if (!done) return;
@@ -402,7 +462,6 @@ const every = (items, fn, done) => {
     proceedItemsCount++;
     if (proceedItemsCount === len) done(null, true);
   };
-
   for (const item of items) fn(item, finish);
 };
 
@@ -418,7 +477,8 @@ const every = (items, fn, done) => {
 //     result - <boolean>
 const some = (items, fn, done) => {
   done = done || common.emptyness;
-  const len = items.length;
+  const len = items.length || items.size;
+  const data = items[Symbol.iterator]();
   let i = 0;
 
   const next = () => {
@@ -426,7 +486,7 @@ const some = (items, fn, done) => {
       done(null, false);
       return;
     }
-    fn(items[i], (err, accepted) => {
+    fn(data.next().value, (err, accepted) => {
       if (err) {
         done(err);
         return;
diff --git a/test/array.asyncMap.js b/test/array.asyncMap.js
index a2deabc3..c071fedf 100644
--- a/test/array.asyncMap.js
+++ b/test/array.asyncMap.js
@@ -3,7 +3,7 @@
 const metasync = require('..');
 const metatests = require('metatests');
 
-metatests.test('succesfull map', test => {
+metatests.test('succesfull map / array', test => {
   test.plan(2);
 
   const arr = [1, 2, 3];
@@ -19,6 +19,54 @@ metatests.test('succesfull map', test => {
   );
 });
 
+metatests.test('succesfull map / set', test => {
+  test.plan(2);
+
+  const set = new Set([1, 2, 3]);
+  const expectedSet = new Set([2, 4, 6]);
+
+  metasync.asyncMap(
+    set,
+    item => item * 2,
+    (err, newArr) => {
+      test.error(err);
+      test.strictSame(newArr, expectedSet);
+    }
+  );
+});
+
+metatests.test('succesfull map / map', test => {
+  test.plan(2);
+
+  const map = new Map([[1, 'a'], [2, 'b'], [3, 'c']]);
+  const expectedMap = new Map([[1, 'a'], [4, 'b'], [9, 'c']]);
+
+  metasync.asyncMap(
+    map,
+    item => item[0] * 2,
+    (err, newArr) => {
+      test.error(err);
+      test.strictSame(newArr, expectedMap);
+    }
+  );
+});
+
+metatests.test('succesfull map / string', test => {
+  test.plan(2);
+
+  const string = 'abcdefgh';
+  const expectedStr = 'ABCDEFGH';
+
+  metasync.asyncMap(
+    string,
+    item => item.toUpperCase(),
+    (err, newArr) => {
+      test.error(err);
+      test.strictSame(newArr, expectedStr);
+    }
+  );
+});
+
 const doSmth = time => {
   const begin = Date.now();
   while (Date.now() - begin < time);
diff --git a/test/array.each.js b/test/array.each.js
index 22b2c4a2..0b5aff06 100644
--- a/test/array.each.js
+++ b/test/array.each.js
@@ -3,7 +3,7 @@
 const metasync = require('..');
 const metatests = require('metatests');
 
-metatests.test('successful each', test => {
+metatests.test('successful each / array', test => {
   const arr = [1, 2, 3, 4];
 
   const elementsSet = new Set();
@@ -24,7 +24,68 @@ metatests.test('successful each', test => {
   );
 });
 
-metatests.test('each with empty array', test => {
+metatests.test('successful each / set', test => {
+  const set = new Set([1, 2, 3, 4, 5]);
+  const elementsSet = new Set();
+
+  metasync.each(
+    set,
+    (el, callback) =>
+      process.nextTick(() => {
+        elementsSet.add(el);
+        callback(null);
+      }),
+    err => {
+      test.error(err);
+      test.strictSame(elementsSet, set);
+      test.end();
+    }
+  );
+});
+
+metatests.test('successful each / map', test => {
+  const map = new Map([[1, 'a'], [2, 'b'], [3, 'c']]);
+
+  const elementsSet = new Set();
+  const expectedElementsSet = new Set(map);
+
+  metasync.each(
+    map,
+    (el, callback) =>
+      process.nextTick(() => {
+        elementsSet.add(el);
+        callback(null);
+      }),
+    err => {
+      test.error(err);
+      test.strictSame(elementsSet, expectedElementsSet);
+      test.end();
+    }
+  );
+});
+
+metatests.test('successful each / string', test => {
+  const string = 'aaabcdeefff';
+
+  const elementsSet = new Set();
+  const expectedElementsSet = new Set();
+
+  metasync.each(
+    string,
+    (el, callback) =>
+      process.nextTick(() => {
+        elementsSet.add(el);
+        callback(null);
+      }),
+    err => {
+      test.error(err);
+      test.strictSame(elementsSet, expectedElementsSet);
+      test.end();
+    }
+  );
+});
+
+metatests.test('each with empty / array', test => {
   const arr = [];
 
   const elementsSet = new Set();
@@ -45,6 +106,68 @@ metatests.test('each with empty array', test => {
   );
 });
 
+metatests.test('each with empty / map', test => {
+  const map = new Map();
+
+  const elementsSet = new Set();
+  const expectedElementsSet = new Set(map);
+
+  metasync.each(
+    map,
+    (el, callback) =>
+      process.nextTick(() => {
+        elementsSet.add(el);
+        callback(null);
+      }),
+    err => {
+      test.error(err);
+      test.strictSame(elementsSet, expectedElementsSet);
+      test.end();
+    }
+  );
+});
+
+metatests.test('each with empty / string', test => {
+  const string = '';
+
+  const elementsSet = new Set();
+  const expectedElementsSet = new Set(string);
+
+  metasync.each(
+    string,
+    (el, callback) =>
+      process.nextTick(() => {
+        elementsSet.add(el);
+        callback(null);
+      }),
+    err => {
+      test.error(err);
+      test.strictSame(elementsSet, expectedElementsSet);
+      test.end();
+    }
+  );
+});
+
+metatests.test('each with empty / set', test => {
+  const set = new Set();
+
+  const elementsSet = new Set();
+
+  metasync.each(
+    set,
+    (el, callback) =>
+      process.nextTick(() => {
+        elementsSet.add(el);
+        callback(null);
+      }),
+    err => {
+      test.error(err);
+      test.strictSame(elementsSet, set);
+      test.end();
+    }
+  );
+});
+
 metatests.test('each with error', test => {
   const arr = [1, 2, 3, 4];
   let count = 0;
diff --git a/test/array.every.js b/test/array.every.js
index fb36a173..75fcdc22 100644
--- a/test/array.every.js
+++ b/test/array.every.js
@@ -60,7 +60,7 @@ metatests.test('every with two-element arrays', test =>
   )
 );
 
-metatests.test('every', test => {
+metatests.test('every / array', test => {
   const data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
 
   const predicate = (item, callback) => {
@@ -73,3 +73,45 @@ metatests.test('every', test => {
     test.end();
   });
 });
+
+metatests.test('every / set', test => {
+  const data = new Set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
+
+  const predicate = (item, callback) => {
+    process.nextTick(() => callback(null, item > 0));
+  };
+
+  metasync.every(data, predicate, (err, result) => {
+    test.error(err);
+    test.strictSame(result, true);
+    test.end();
+  });
+});
+
+metatests.test('every / map', test => {
+  const data = new Map([[1, 'a'], [2, 'b'], [3, 'c']]);
+
+  const predicate = (item, callback) => {
+    process.nextTick(() => callback(null, item[0] > 0));
+  };
+
+  metasync.every(data, predicate, (err, result) => {
+    test.error(err);
+    test.strictSame(result, true);
+    test.end();
+  });
+});
+
+metatests.test('every / string', test => {
+  const data = 'aaaaaaaaaaaa';
+
+  const predicate = (item, callback) => {
+    process.nextTick(() => callback(null, item === 'a'));
+  };
+
+  metasync.every(data, predicate, (err, result) => {
+    test.error(err);
+    test.strictSame(result, true);
+    test.end();
+  });
+});
diff --git a/test/array.filter.js b/test/array.filter.js
index 55528e85..98038d21 100644
--- a/test/array.filter.js
+++ b/test/array.filter.js
@@ -3,7 +3,7 @@
 const metasync = require('..');
 const metatests = require('metatests');
 
-metatests.test('successful filter', test => {
+metatests.test('successful filter / array', test => {
   const arr = [
     'Lorem',
     'ipsum',
@@ -44,29 +44,14 @@ metatests.test('successful filter', test => {
     (str, callback) => process.nextTick(() => callback(null, str.length < 6)),
     (err, res) => {
       test.error(err);
-      test.same(res.join(), expectedArr.join());
+      test.same(res, expectedArr);
       test.end();
     }
   );
 });
 
-metatests.test('filter with empty array', test => {
-  const arr = [];
-  const expectedArr = [];
-
-  metasync.filter(
-    arr,
-    (str, callback) => process.nextTick(() => callback(null, str.length < 6)),
-    (err, res) => {
-      test.error(err);
-      test.strictSame(res, expectedArr);
-      test.end();
-    }
-  );
-});
-
-metatests.test('successful filter', test => {
-  const arr = [
+metatests.test('successful filter / set', test => {
+  const set = new Set([
     'Lorem',
     'ipsum',
     'dolor',
@@ -86,9 +71,8 @@ metatests.test('successful filter', test => {
     'dolore',
     'magna',
     'aliqua',
-  ];
-  const filterError = new Error('Filter error');
-  const expectedArr = [
+  ]);
+  const expectedSet = new Set([
     'Lorem',
     'ipsum',
     'dolor',
@@ -97,10 +81,11 @@ metatests.test('successful filter', test => {
     'elit',
     'sed',
     'magna',
-  ];
+  ]);
+  const filterError = new Error('Filter error');
 
   metasync.filter(
-    arr,
+    set,
     (str, callback) =>
       process.nextTick(() => {
         if (str.length === 2) {
@@ -111,7 +96,103 @@ metatests.test('successful filter', test => {
       }),
     (err, res) => {
       test.error(err);
-      test.same(res.join(), expectedArr.join());
+      test.same(res, expectedSet);
+      test.end();
+    }
+  );
+});
+
+metatests.test('successful filter / map', test => {
+  const map = new Map([[1, 'a'], [2, 'b'], [3, 'c'], [4, 'd'], [5, 'e']]);
+  const expectedMap = new Map([[4, 'd'], [5, 'e']]);
+
+  metasync.filter(
+    map,
+    (el, callback) =>
+      process.nextTick(() => {
+        callback(null, el[0] > 3);
+      }),
+    (err, res) => {
+      test.error(err);
+      test.same(res, expectedMap);
+      test.end();
+    }
+  );
+});
+
+metatests.test('successful filter / string', test => {
+  const string = 'aaabcfeeeeds';
+  const expectedSet = 'aaaeeee';
+
+  metasync.filter(
+    string,
+    (el, callback) =>
+      process.nextTick(() => {
+        callback(null, el === 'a' || el === 'e');
+      }),
+    (err, res) => {
+      test.error(err);
+      test.same(res, expectedSet);
+      test.end();
+    }
+  );
+});
+
+metatests.test('filter with empty / array', test => {
+  const arr = [];
+  const expectedArr = [];
+
+  metasync.filter(
+    arr,
+    (str, callback) => process.nextTick(() => callback(null, str.length < 6)),
+    (err, res) => {
+      test.error(err);
+      test.strictSame(res, expectedArr);
+      test.end();
+    }
+  );
+});
+
+metatests.test('filter with empty / set', test => {
+  const set = new Set();
+  const expectedArr = new Set();
+
+  metasync.filter(
+    set,
+    (str, callback) => process.nextTick(() => callback(null, str.length < 6)),
+    (err, res) => {
+      test.error(err);
+      test.strictSame(res, expectedArr);
+      test.end();
+    }
+  );
+});
+
+metatests.test('filter with empty / map', test => {
+  const set = new Map();
+  const expectedArr = new Map();
+
+  metasync.filter(
+    set,
+    (str, callback) => process.nextTick(() => callback(null, str.length < 6)),
+    (err, res) => {
+      test.error(err);
+      test.strictSame(res, expectedArr);
+      test.end();
+    }
+  );
+});
+
+metatests.test('filter with empty / string', test => {
+  const set = '';
+  const expectedArr = '';
+
+  metasync.filter(
+    set,
+    (str, callback) => process.nextTick(() => callback(null, str.length < 6)),
+    (err, res) => {
+      test.error(err);
+      test.strictSame(res, expectedArr);
       test.end();
     }
   );
diff --git a/test/array.find.js b/test/array.find.js
index fa26a458..7b3849e1 100644
--- a/test/array.find.js
+++ b/test/array.find.js
@@ -22,7 +22,7 @@ metatests.test('find with error', test => {
   });
 });
 
-metatests.test('find', test => {
+metatests.test('find / array', test => {
   const data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
   const expected = 15;
   const predicate = (item, callback) =>
@@ -35,7 +35,46 @@ metatests.test('find', test => {
   });
 });
 
-metatests.test('with empty array', test => {
+metatests.test('find / set', test => {
+  const data = new Set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
+  const expected = 15;
+  const predicate = (item, callback) =>
+    process.nextTick(() => callback(null, item % 3 === 0 && item % 5 === 0));
+
+  metasync.find(data, predicate, (err, result) => {
+    test.error(err, 'must not return an error');
+    test.strictSame(result, expected, `result should be: ${expected}`);
+    test.end();
+  });
+});
+
+metatests.test('find / map', test => {
+  const data = new Map([[1, 'a'], [2, 'b'], [3, 'c']]);
+  const expected = 3;
+  const predicate = (item, callback) =>
+    process.nextTick(() => callback(null, item[0] % 3 === 0));
+
+  metasync.find(data, predicate, (err, result) => {
+    test.error(err, 'must not return an error');
+    test.strictSame(result[0], expected, `result should be: ${expected}`);
+    test.end();
+  });
+});
+
+metatests.test('find / string', test => {
+  const data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
+  const expected = 15;
+  const predicate = (item, callback) =>
+    process.nextTick(() => callback(null, item % 3 === 0 && item % 5 === 0));
+
+  metasync.find(data, predicate, (err, result) => {
+    test.error(err, 'must not return an error');
+    test.strictSame(result, expected, `result should be: ${expected}`);
+    test.end();
+  });
+});
+
+metatests.test('with empty / array', test => {
   metasync.find(
     [],
     (el, callback) => process.nextTick(() => callback(null, true)),
@@ -47,6 +86,42 @@ metatests.test('with empty array', test => {
   );
 });
 
+metatests.test('with empty / set', test => {
+  metasync.find(
+    new Set(),
+    (el, callback) => process.nextTick(() => callback(null, true)),
+    (err, result) => {
+      test.error(err);
+      test.strictSame(result, undefined);
+      test.end();
+    }
+  );
+});
+
+metatests.test('with empty / map', test => {
+  metasync.find(
+    new Map(),
+    (el, callback) => process.nextTick(() => callback(null, true)),
+    (err, result) => {
+      test.error(err);
+      test.strictSame(result, undefined);
+      test.end();
+    }
+  );
+});
+
+metatests.test('with empty / string', test => {
+  metasync.find(
+    '',
+    (el, callback) => process.nextTick(() => callback(null, true)),
+    (err, result) => {
+      test.error(err);
+      test.strictSame(result, undefined);
+      test.end();
+    }
+  );
+});
+
 metatests.test('with array without element which is searching', test => {
   const data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
   metasync.find(
diff --git a/test/array.map.js b/test/array.map.js
index f059774a..5ab93e14 100644
--- a/test/array.map.js
+++ b/test/array.map.js
@@ -3,7 +3,7 @@
 const metasync = require('..');
 const metatests = require('metatests');
 
-metatests.test('succesfull map', test => {
+metatests.test('succesfull map / array', test => {
   const arr = [1, 2, 3];
   const expectedArr = [1, 4, 9];
 
@@ -18,7 +18,52 @@ metatests.test('succesfull map', test => {
   );
 });
 
-metatests.test('map with empty array', test => {
+metatests.test('succesfull map / set', test => {
+  const set = new Set([1, 2, 3]);
+  const expectedSet = new Set([1, 4, 9]);
+
+  metasync.map(
+    set,
+    (x, callback) => process.nextTick(() => callback(null, x * x)),
+    (err, res) => {
+      test.error(err);
+      test.strictSame(res, expectedSet);
+      test.end();
+    }
+  );
+});
+
+metatests.test('succesfull map / map', test => {
+  const map = new Map([[1, 'a'], [2, 'b'], [3, 'c']]);
+  const expectedMap = new Map([[1, 'a'], [4, 'b'], [9, 'c']]);
+
+  metasync.map(
+    map,
+    (x, callback) => process.nextTick(() => callback(null, x[0] * x[0])),
+    (err, res) => {
+      test.error(err);
+      test.strictSame(res, expectedMap);
+      test.end();
+    }
+  );
+});
+
+metatests.test('succesfull map / string', test => {
+  const string = 'abcdefgh';
+  const expectedStr = 'ABCDEFGH';
+
+  metasync.map(
+    string,
+    (x, callback) => process.nextTick(() => callback(null, x.toUpperCase())),
+    (err, res) => {
+      test.error(err);
+      test.strictSame(res, expectedStr);
+      test.end();
+    }
+  );
+});
+
+metatests.test('map with empty / array', test => {
   const arr = [];
   const expectedArr = [];
 
@@ -33,6 +78,51 @@ metatests.test('map with empty array', test => {
   );
 });
 
+metatests.test('map with empty / set', test => {
+  const set = new Set();
+  const expectedSet = new Set();
+
+  metasync.map(
+    set,
+    (x, callback) => process.nextTick(() => callback(null, x * x)),
+    (err, res) => {
+      test.error(err);
+      test.strictSame(res, expectedSet);
+      test.end();
+    }
+  );
+});
+
+metatests.test('map with empty / map', test => {
+  const map = new Map();
+  const expectedMap = new Map();
+
+  metasync.map(
+    map,
+    (x, callback) => process.nextTick(() => callback(null, x * x)),
+    (err, res) => {
+      test.error(err);
+      test.strictSame(res, expectedMap);
+      test.end();
+    }
+  );
+});
+
+metatests.test('map with empty / string', test => {
+  const str = '';
+  const expectedStr = '';
+
+  metasync.map(
+    str,
+    (x, callback) => process.nextTick(() => callback(null, x * x)),
+    (err, res) => {
+      test.error(err);
+      test.strictSame(res, expectedStr);
+      test.end();
+    }
+  );
+});
+
 metatests.test('map with error', test => {
   const arr = [1, 2, 3];
   const mapError = new Error('Map error');
diff --git a/test/array.reduce.js b/test/array.reduce.js
index 21028eac..ae5368a4 100644
--- a/test/array.reduce.js
+++ b/test/array.reduce.js
@@ -3,7 +3,7 @@
 const metasync = require('..');
 const metatests = require('metatests');
 
-metatests.test('reduce with initial', test => {
+metatests.test('reduce with initial / array', test => {
   const arr = [1, 2, 3, 4, 5];
   const initial = 10;
   const expectedRes = 25;
@@ -20,6 +20,58 @@ metatests.test('reduce with initial', test => {
   );
 });
 
+metatests.test('reduce with initial / set', test => {
+  const set = new Set([1, 2, 3, 4, 5]);
+  const initial = 10;
+  const expectedRes = 25;
+
+  metasync.reduce(
+    set,
+    (prev, cur, callback) => process.nextTick(() => callback(null, prev + cur)),
+    (err, res) => {
+      test.error(err);
+      test.strictSame(res, expectedRes);
+      test.end();
+    },
+    initial
+  );
+});
+
+metatests.test('reduce with initial / map', test => {
+  const map = new Map([[1, 'a'], [2, 'b'], [3, 'c']]);
+  const initial = 10;
+  const expectedRes = '101,a2,b3,c';
+
+  metasync.reduce(
+    map,
+    (prev, cur, callback) => process.nextTick(() => callback(null, prev + cur)),
+    (err, res) => {
+      test.error(err);
+      test.strictSame(res, expectedRes);
+      test.end();
+    },
+    initial
+  );
+});
+
+metatests.test('reduce with initial / string', test => {
+  const str = '1111111111';
+  const expectedRes = 20;
+  const initial = 10;
+
+  metasync.reduce(
+    str,
+    (prev, cur, callback) =>
+      process.nextTick(() => callback(null, +prev + +cur)),
+    (err, res) => {
+      test.error(err);
+      test.strictSame(res, expectedRes);
+      test.end();
+    },
+    initial
+  );
+});
+
 metatests.test('reduce with initial and empty array', test => {
   const arr = [];
   const initial = 10;
diff --git a/test/array.reduceRight.js b/test/array.reduceRight.js
index a3fe9da9..0d1252dc 100644
--- a/test/array.reduceRight.js
+++ b/test/array.reduceRight.js
@@ -3,7 +3,7 @@
 const metasync = require('..');
 const metatests = require('metatests');
 
-metatests.test('reduceRight with initial', test => {
+metatests.test('reduceRight with initial / array', test => {
   const arr = [1, 2, 3, 4, 5];
   const initial = 10;
   const expectedRes = 25;
@@ -20,6 +20,58 @@ metatests.test('reduceRight with initial', test => {
   );
 });
 
+metatests.test('reduce with initial / set', test => {
+  const set = new Set([1, 2, 3, 4, 5]);
+  const initial = 10;
+  const expectedRes = 25;
+
+  metasync.reduceRight(
+    set,
+    (prev, cur, callback) => process.nextTick(() => callback(null, prev + cur)),
+    (err, res) => {
+      test.error(err);
+      test.strictSame(res, expectedRes);
+      test.end();
+    },
+    initial
+  );
+});
+
+metatests.test('reduce with initial / map', test => {
+  const map = new Map([[1, 'a'], [2, 'b'], [3, 'c']]);
+  const initial = 10;
+  const expectedRes = '103,c2,b1,a';
+
+  metasync.reduceRight(
+    map,
+    (prev, cur, callback) => process.nextTick(() => callback(null, prev + cur)),
+    (err, res) => {
+      test.error(err);
+      test.strictSame(res, expectedRes);
+      test.end();
+    },
+    initial
+  );
+});
+
+metatests.test('reduce with initial / string', test => {
+  const str = '1111111111';
+  const expectedRes = 20;
+  const initial = 10;
+
+  metasync.reduceRight(
+    str,
+    (prev, cur, callback) =>
+      process.nextTick(() => callback(null, +prev + +cur)),
+    (err, res) => {
+      test.error(err);
+      test.strictSame(res, expectedRes);
+      test.end();
+    },
+    initial
+  );
+});
+
 metatests.test('reduceRight with initial and empty array', test => {
   const arr = [];
   const initial = 10;
diff --git a/test/array.series.js b/test/array.series.js
index 5171d893..ecb3dbb2 100644
--- a/test/array.series.js
+++ b/test/array.series.js
@@ -3,7 +3,7 @@
 const metasync = require('..');
 const metatests = require('metatests');
 
-metatests.test('successful series', test => {
+metatests.test('successful series / array', test => {
   const arr = [1, 2, 3, 4];
   const expectedElements = arr;
   const elements = [];
@@ -21,6 +21,60 @@ metatests.test('successful series', test => {
   );
 });
 
+metatests.test('successful series / set', test => {
+  const set = new Set([1, 2, 3, 4]);
+  const expectedElements = set;
+  const elements = new Set();
+  metasync.series(
+    set,
+    (el, callback) => {
+      elements.add(el);
+      callback(null);
+    },
+    err => {
+      test.error(err);
+      test.strictSame(elements, expectedElements);
+      test.end();
+    }
+  );
+});
+
+metatests.test('successful series / map', test => {
+  const map = new Map([[1, 'a'], [2, 'b'], [3, 'c']]);
+  const expectedElements = new Set(map);
+  const elements = new Set();
+  metasync.series(
+    map,
+    (el, callback) => {
+      elements.add(el);
+      callback(null);
+    },
+    err => {
+      test.error(err);
+      test.strictSame(elements, expectedElements);
+      test.end();
+    }
+  );
+});
+
+metatests.test('successful series / string', test => {
+  const string = 'abcdefg1234';
+  const expectedElements = new Set(string);
+  const elements = new Set();
+  metasync.series(
+    string,
+    (el, callback) => {
+      elements.add(el);
+      callback(null);
+    },
+    err => {
+      test.error(err);
+      test.strictSame(elements, expectedElements);
+      test.end();
+    }
+  );
+});
+
 metatests.test('series with error', test => {
   const arr = [1, 2, 3, 4];
   const expectedElements = [1, 2];
diff --git a/test/array.some.js b/test/array.some.js
index bb12bcea..3f69f5e7 100644
--- a/test/array.some.js
+++ b/test/array.some.js
@@ -3,7 +3,7 @@
 const metasync = require('..');
 const metatests = require('metatests');
 
-metatests.test('successful some', test => {
+metatests.test('successful some / array', test => {
   const arr = [1, 2, 3];
 
   const predicate = (x, callback) => callback(null, x % 2 === 0);
@@ -14,7 +14,40 @@ metatests.test('successful some', test => {
   });
 });
 
-metatests.test('failing some', test => {
+metatests.test('successful some / set', test => {
+  const set = new Set([1, 2, 3, 4, 5]);
+
+  const predicate = (x, callback) => callback(null, x % 2 === 0);
+  metasync.some(set, predicate, (err, accepted) => {
+    test.error(err);
+    test.strictSame(accepted, true);
+    test.end();
+  });
+});
+
+metatests.test('successful some / map', test => {
+  const map = new Map([[1, 'a'], [2, 'b'], [3, 'c']]);
+
+  const predicate = (x, callback) => callback(null, x[0] % 2 === 0);
+  metasync.some(map, predicate, (err, accepted) => {
+    test.error(err);
+    test.strictSame(accepted, true);
+    test.end();
+  });
+});
+
+metatests.test('successful some / string', test => {
+  const string = 'abcdeeef12343';
+
+  const predicate = (x, callback) => callback(null, x === 'e');
+  metasync.some(string, predicate, (err, accepted) => {
+    test.error(err);
+    test.strictSame(accepted, true);
+    test.end();
+  });
+});
+
+metatests.test('failing some / array', test => {
   const arr = [1, 2, 3];
 
   const predicate = (x, callback) => callback(null, x > 3);
@@ -25,20 +58,40 @@ metatests.test('failing some', test => {
   });
 });
 
-metatests.test('erroneous some', test => {
-  const arr = [1, 2, 3];
-  const someError = new Error('Some error');
+metatests.test('failing some / set', test => {
+  const set = new Set([1, 2, 3, 4, 5]);
 
-  const predicate = (x, callback) =>
-    x % 2 === 0 ? callback(someError) : callback(null, false);
-  metasync.some(arr, predicate, (err, accepted) => {
-    test.strictSame(err, someError);
-    test.strictSame(accepted, undefined);
+  const predicate = (x, callback) => callback(null, x > 6);
+  metasync.some(set, predicate, (err, accepted) => {
+    test.error(err);
+    test.strictSame(accepted, false);
+    test.end();
+  });
+});
+
+metatests.test('failing some / map', test => {
+  const map = new Map([[1, 'a'], [2, 'b'], [3, 'c']]);
+
+  const predicate = (x, callback) => callback(null, x[0] > 3);
+  metasync.some(map, predicate, (err, accepted) => {
+    test.error(err);
+    test.strictSame(accepted, false);
     test.end();
   });
 });
 
-metatests.test('some with empty array', test => {
+metatests.test('failing some / string', test => {
+  const string = 'abcdeeef12343';
+
+  const predicate = (x, callback) => callback(null, x === 'u');
+  metasync.some(string, predicate, (err, accepted) => {
+    test.error(err);
+    test.strictSame(accepted, false);
+    test.end();
+  });
+});
+
+metatests.test('some with empty / array', test => {
   const arr = [];
 
   const predicate = (x, callback) => callback(null, x > 3);
@@ -48,3 +101,49 @@ metatests.test('some with empty array', test => {
     test.end();
   });
 });
+
+metatests.test('some with empty / set', test => {
+  const set = new Set();
+
+  const predicate = (x, callback) => callback(null, x > 3);
+  metasync.some(set, predicate, (err, accepted) => {
+    test.error(err);
+    test.strictSame(accepted, false);
+    test.end();
+  });
+});
+
+metatests.test('some with empty / map', test => {
+  const map = new Map();
+
+  const predicate = (x, callback) => callback(null, x[0] > 3);
+  metasync.some(map, predicate, (err, accepted) => {
+    test.error(err);
+    test.strictSame(accepted, false);
+    test.end();
+  });
+});
+
+metatests.test('some with empty / string', test => {
+  const string = '';
+
+  const predicate = (x, callback) => callback(null, x === 'e');
+  metasync.some(string, predicate, (err, accepted) => {
+    test.error(err);
+    test.strictSame(accepted, false);
+    test.end();
+  });
+});
+
+metatests.test('erroneous some', test => {
+  const arr = [1, 2, 3];
+  const someError = new Error('Some error');
+
+  const predicate = (x, callback) =>
+    x % 2 === 0 ? callback(someError) : callback(null, false);
+  metasync.some(arr, predicate, (err, accepted) => {
+    test.strictSame(err, someError);
+    test.strictSame(accepted, undefined);
+    test.end();
+  });
+});