Speed up native types

There is a good opportunity to speed up some of the functions, when they are a native type (array string, TypedArray). For example:

import ensureIterable from './internal/ensure-iterable'

export default function size (iterable) {
  if (typeof iterable === 'string') return iterable.length
  let size = 0
  // eslint-disable-next-line
  for (const _ of ensureIterable(iterable)) {
    size++
  }
  return size
}

There is an important caveat though. It is important to decide a cut-off point based on the size of the data structure: It can be a nice improvement using array.prototype.map whenever the size of the array is not big. But it can blow up the memory otherwise.

[KSXGitHub]

Regarding the sparse array earlier, Array.from (and/or spread operator ([...arr])) should be able to fix the problem. Array.from should also be used on typed arrays (Int8Array, Int16Array, etc.) if we were to call .map() because despite typed arrays don’t have holes, their map functions never returns array of other types.

As for .filter() on typed arrays, you can call it directly without cloning.

[sithmel]

I am going to rename it to TypedArrayProto. It is explained here: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#Description