def then(self, success=None, failure=None):
        """
        This method takes two optional arguments.  The first argument
        is used if the "self promise" is fulfilled and the other is
        used if the "self promise" is rejected.  In either case, this
        method returns another promise that effectively represents
        the result of either the first of the second argument (in the
        case that the "self promise" is fulfilled or rejected,
        respectively).

        Each argument can be either:
          * None - Meaning no action is taken
          * A function - which will be called with either the value
            of the "self promise" or the reason for rejection of
            the "self promise".  The function may return:
            * A value - which will be used to fulfill the promise
              returned by this method.
            * A promise - which, when fulfilled or rejected, will
              cascade its value or reason to the promise returned
              by this method.
          * A value - which will be assigned as either the value
            or the reason for the promise returned by this method
            when the "self promise" is either fulfilled or rejected,
            respectively.
        """
        ret = Promise()

        def callAndFulfill(v):
            """
            A callback to be invoked if the "self promise"
            is fulfilled.
            """
            try:
                # From 3.2.1, don't call non-functions values
                if _isFunction(success):
                    newvalue = success(v)
                    if _isPromise(newvalue):
                        newvalue.then(lambda v: ret.fulfill(v),
                                      lambda r: ret.reject(r))
                    else:
                        ret.fulfill(newvalue)
                elif success!=None:
                    # From 3.2.6.4
                    ret.fulfill(v)
                else:
                    pass
            except Exception as e:
                ret.reject(e)

        def callAndReject(r):
            """
            A callback to be invoked if the "self promise"
            is rejected.
            """
            try:
                if _isFunction(failure):
                    newvalue = failure(r)
                    if _isPromise(newvalue):
                        newvalue.then(lambda v: ret.fulfill(v),
                                      lambda r: ret.reject(r))
                    else:
                        ret.fulfill(newvalue)
                elif failure!=None:
                    # From 3.2.6.5
                    ret.reject(r)
                else:
                    pass
            except Exception as e:
                ret.reject(e)
        
        if self._state==self.PENDING:
            """
            If this is still pending, then add callbacks to the
            existing promise that call either the success or
            rejected functions supplied and then fulfill the
            promise being returned by this method
            """
            if success!=None:
                self._callbacks.append(callAndFulfill)
            if failure!=None:
                self._errbacks.append(callAndReject)

        elif self._state==self.FULFILLED:
            """
            If this promise was already fulfilled, then
            we need to use the first argument to this method
            to determine the value to use in fulfilling the
            promise that we return from this method.
            """
            try:
                if _isFunction(success):
                    newvalue = success(self.value)
                    if _isPromise(newvalue):
                        newvalue.then(lambda v: ret.fulfill(v),
                                      lambda r: ret.reject(r))
                    else:
                        ret.fulfill(newvalue)
                elif success!=None:
                    # From 3.2.6.4
                    ret.fulfill(self.value)
                else:
                    pass
            except Exception as e:
                ret.reject(e)
        elif self._state==self.REJECTED:
            """
            If this promise was already rejected, then
            we need to use the second argument to this method
            to determine the value to use in fulfilling the
            promise that we return from this method.
            """
            try:
                if _isFunction(failure):
                    newvalue = failure(self.reason)
                    if _isPromise(newvalue):
                        newvalue.then(lambda v: ret.fulfill(v),
                                      lambda r: ret.reject(r))
                    else:
                        ret.fulfill(newvalue)
                elif failure!=None:
                    # From 3.2.6.5
                    ret.reject(self.reason)
                else:
                    pass
            except Exception as e:
                ret.reject(e)

        return ret
This method takes two optional arguments.  The first argument
        is used if the "self promise" is fulfilled and the other is
        used if the "self promise" is rejected.  In either case, this
        method returns another promise that effectively represents
        the result of either the first of the second argument (in the
        case that the "self promise" is fulfilled or rejected,
        respectively).

        Each argument can be either:
          * None - Meaning no action is taken
          * A function - which will be called with either the value
            of the "self promise" or the reason for rejection of
            the "self promise".  The function may return:
            * A value - which will be used to fulfill the promise
              returned by this method.
            * A promise - which, when fulfilled or rejected, will
              cascade its value or reason to the promise returned
              by this method.
          * A value - which will be assigned as either the value
            or the reason for the promise returned by this method
            when the "self promise" is either fulfilled or rejected,
            respectively.