code: function groupBy(iterable, iteratee=identity) {
    // TODO: How does looped reassignment like this behave in terms of memory usage?
    let result = Map()
    for (let entry of iterable.entrySeq()) {
      let [key, value] = entry
      const keyed = iteratee(value)
      const collector = result.get(keyed, List()).push(key)
      result = result.set(keyed, collector)
    }
    return result
  }
docs: Creates a map composed of keys generated from the results of running
  each element of `iterable` through `iteratee`. The order of grouped values
  is determined by the order they occur in `iterable`. The corresponding
  value of each key is a List of elements responsible for generating the
  key. The iteratee is invoked with one argument: (value).
  
  @static
  @memberOf _
  @category iterable
  @param {Iterable} iterable The iterable to iterate over.
  @param {Function} [iteratee=_.identity]
  The iteratee to transform keys.
  @returns {Map} Returns the composed aggregate map.
  @example
  
  _.groupBy([6.1, 4.2, 6.3], Math.floor)
  // => { '4': [4.2], '6': [6.1, 6.3] }