whole_func_string: function() {
      var pending = [],
          value, deferred;
  
      deferred = {
  
        resolve: function(val) {
          if (pending) {
            var callbacks = pending;
            pending = undefined;
            value = ref(val);
  
            if (callbacks.length) {
              nextTick(function() {
                var callback;
                for (var i = 0, ii = callbacks.length; i < ii; i++) {
                  callback = callbacks[i];
                  value.then(callback[0], callback[1], callback[2]);
                }
              });
            }
          }
        },
  
  
        reject: function(reason) {
          deferred.resolve(createInternalRejectedPromise(reason));
        },
  
  
        notify: function(progress) {
          if (pending) {
            var callbacks = pending;
  
            if (pending.length) {
              nextTick(function() {
                var callback;
                for (var i = 0, ii = callbacks.length; i < ii; i++) {
                  callback = callbacks[i];
                  callback[2](progress);
                }
              });
            }
          }
        },
  
  
        promise: {
          then: function(callback, errback, progressback) {
            var result = defer();
  
            var wrappedCallback = function(value) {
              try {
                result.resolve((isFunction(callback) ? callback : defaultCallback)(value));
              } catch(e) {
                result.reject(e);
                exceptionHandler(e);
              }
            };
  
            var wrappedErrback = function(reason) {
              try {
                result.resolve((isFunction(errback) ? errback : defaultErrback)(reason));
              } catch(e) {
                result.reject(e);
                exceptionHandler(e);
              }
            };
  
            var wrappedProgressback = function(progress) {
              try {
                result.notify((isFunction(progressback) ? progressback : defaultCallback)(progress));
              } catch(e) {
                exceptionHandler(e);
              }
            };
  
            if (pending) {
              pending.push([wrappedCallback, wrappedErrback, wrappedProgressback]);
            } else {
              value.then(wrappedCallback, wrappedErrback, wrappedProgressback);
            }
  
            return result.promise;
          },
  
          "catch": function(callback) {
            return this.then(null, callback);
          },
  
          "finally": function(callback) {
  
            function makePromise(value, resolved) {
              var result = defer();
              if (resolved) {
                result.resolve(value);
              } else {
                result.reject(value);
              }
              return result.promise;
            }
  
            function handleCallback(value, isResolved) {
              var callbackOutput = null;
              try {
                callbackOutput = (callback ||defaultCallback)();
              } catch(e) {
                return makePromise(e, false);
              }
              if (isPromiseLike(callbackOutput)) {
                return callbackOutput.then(function() {
                  return makePromise(value, isResolved);
                }, function(error) {
                  return makePromise(error, false);
                });
              } else {
                return makePromise(value, isResolved);
              }
            }
  
            return this.then(function(value) {
              return handleCallback(value, true);
            }, function(error) {
              return handleCallback(error, false);
            });
          }
        }
      };
  
      return deferred;
    }
func_code_string: function() {
      var pending = [],
          value, deferred;
  
      deferred = {
  
        resolve: function(val) {
          if (pending) {
            var callbacks = pending;
            pending = undefined;
            value = ref(val);
  
            if (callbacks.length) {
              nextTick(function() {
                var callback;
                for (var i = 0, ii = callbacks.length; i < ii; i++) {
                  callback = callbacks[i];
                  value.then(callback[0], callback[1], callback[2]);
                }
              });
            }
          }
        },
  
  
        reject: function(reason) {
          deferred.resolve(createInternalRejectedPromise(reason));
        },
  
  
        notify: function(progress) {
          if (pending) {
            var callbacks = pending;
  
            if (pending.length) {
              nextTick(function() {
                var callback;
                for (var i = 0, ii = callbacks.length; i < ii; i++) {
                  callback = callbacks[i];
                  callback[2](progress);
                }
              });
            }
          }
        },
  
  
        promise: {
          then: function(callback, errback, progressback) {
            var result = defer();
  
            var wrappedCallback = function(value) {
              try {
                result.resolve((isFunction(callback) ? callback : defaultCallback)(value));
              } catch(e) {
                result.reject(e);
                exceptionHandler(e);
              }
            };
  
            var wrappedErrback = function(reason) {
              try {
                result.resolve((isFunction(errback) ? errback : defaultErrback)(reason));
              } catch(e) {
                result.reject(e);
                exceptionHandler(e);
              }
            };
  
            var wrappedProgressback = function(progress) {
              try {
                result.notify((isFunction(progressback) ? progressback : defaultCallback)(progress));
              } catch(e) {
                exceptionHandler(e);
              }
            };
  
            if (pending) {
              pending.push([wrappedCallback, wrappedErrback, wrappedProgressback]);
            } else {
              value.then(wrappedCallback, wrappedErrback, wrappedProgressback);
            }
  
            return result.promise;
          },
  
          "catch": function(callback) {
            return this.then(null, callback);
          },
  
          "finally": function(callback) {
  
            function makePromise(value, resolved) {
              var result = defer();
              if (resolved) {
                result.resolve(value);
              } else {
                result.reject(value);
              }
              return result.promise;
            }
  
            function handleCallback(value, isResolved) {
              var callbackOutput = null;
              try {
                callbackOutput = (callback ||defaultCallback)();
              } catch(e) {
                return makePromise(e, false);
              }
              if (isPromiseLike(callbackOutput)) {
                return callbackOutput.then(function() {
                  return makePromise(value, isResolved);
                }, function(error) {
                  return makePromise(error, false);
                });
              } else {
                return makePromise(value, isResolved);
              }
            }
  
            return this.then(function(value) {
              return handleCallback(value, true);
            }, function(error) {
              return handleCallback(error, false);
            });
          }
        }
      };
  
      return deferred;
    }
func_documentation_string: @ngdoc method
  @name $q#defer
  @kind function
  
  @description
  Creates a `Deferred` object which represents a task which will finish in the future.
  
  @returns {Deferred} Returns a new instance of deferred.