'use strict';
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  exports.default = memoize;
  
  var _identity = require('lodash/identity');
  
  var _identity2 = _interopRequireDefault(_identity);
  
  var _slice = require('./internal/slice');
  
  var _slice2 = _interopRequireDefault(_slice);
  
  var _setImmediate = require('./internal/setImmediate');
  
  var _setImmediate2 = _interopRequireDefault(_setImmediate);
  
  var _initialParams = require('./internal/initialParams');
  
  var _initialParams2 = _interopRequireDefault(_initialParams);
  
  var _wrapAsync = require('./internal/wrapAsync');
  
  var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  function has(obj, key) {
      return key in obj;
  }
  
  /**
   * Caches the results of an async function. When creating a hash to store
   * function results against, the callback is omitted from the hash and an
   * optional hash function can be used.
   *
   * If no hash function is specified, the first argument is used as a hash key,
   * which may work reasonably if it is a string or a data type that converts to a
   * distinct string. Note that objects and arrays will not behave reasonably.
   * Neither will cases where the other arguments are significant. In such cases,
   * specify your own hash function.
   *
   * The cache of results is exposed as the `memo` property of the function
   * returned by `memoize`.
   *
   * @name memoize
   * @static
   * @memberOf module:Utils
   * @method
   * @category Util
   * @param {AsyncFunction} fn - The async function to proxy and cache results from.
   * @param {Function} hasher - An optional function for generating a custom hash
   * for storing results. It has all the arguments applied to it apart from the
   * callback, and must be synchronous.
   * @returns {AsyncFunction} a memoized version of `fn`
   * @example
   *
   * var slow_fn = function(name, callback) {
   *     // do something
   *     callback(null, result);
   * };
   * var fn = async.memoize(slow_fn);
   *
   * // fn can now be used as if it were slow_fn
   * fn('some name', function() {
   *     // callback
   * });
   */
  function memoize(fn, hasher) {
      var memo = Object.create(null);
      var queues = Object.create(null);
      hasher = hasher || _identity2.default;
      var _fn = (0, _wrapAsync2.default)(fn);
      var memoized = (0, _initialParams2.default)(function memoized(args, callback) {
          var key = hasher.apply(null, args);
          if (has(memo, key)) {
              (0, _setImmediate2.default)(function () {
                  callback.apply(null, memo[key]);
              });
          } else if (has(queues, key)) {
              queues[key].push(callback);
          } else {
              queues[key] = [callback];
              _fn.apply(null, args.concat(function () /*args*/{
                  var args = (0, _slice2.default)(arguments);
                  memo[key] = args;
                  var q = queues[key];
                  delete queues[key];
                  for (var i = 0, l = q.length; i < l; i++) {
                      q[i].apply(null, args);
                  }
              }));
          }
      });
      memoized.memo = memo;
      memoized.unmemoized = fn;
      return memoized;
  }
  module.exports = exports['default'];