Today, while reviewing the implementation mechanism of Spring Transactions, I noticed that the TransactionAspectSupport class includes additional code to perform logical checks specifically for the Vavr library:

public abstract class TransactionAspectSupport implements BeanFactoryAware, InitializingBean {
    /**
     * Vavr library present on the classpath?
     */
    private static final boolean vavrPresent = ClassUtils.isPresent(
            "io.vavr.control.Try", TransactionAspectSupport.class.getClassLoader());

        .. unrelated code ...

    @Nullable
    protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
            final InvocationCallback invocation) throws Throwable {

        // If the transaction attribute is null, the method is non-transactional.
        ....

        if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager cpptm)) {
            // Standard transaction demarcation with getTransaction and commit/rollback calls.
            TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);

            Object retVal;
            ...

            if (retVal != null && txAttr != null) {
                TransactionStatus status = txInfo.getTransactionStatus();
                if (status != null) {
                    if (retVal instanceof Future<?> future && future.isDone()) {
                        try {
                            future.get();
                        }
                        catch (ExecutionException ex) {
                            Throwable cause = ex.getCause();
                            Assert.state(cause != null, "Cause must not be null");
                            if (txAttr.rollbackOn(cause)) {
                                status.setRollbackOnly();
                            }
                        }
                        catch (InterruptedException ex) {
                            Thread.currentThread().interrupt();
                        }
                    }
// vavr check ->
                    else if (vavrPresent && VavrDelegate.isVavrTry(retVal)) {
                        // Set rollback-only in case of Vavr failure matching our rollback rules...
                        retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
                    }
                }
            }

            commitTransactionAfterReturning(txInfo);
            return retVal;
        }

        else {
            Object result;
            final ThrowableHolder throwableHolder = new ThrowableHolder();

            // It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
            try {
                result = cpptm.execute(txAttr, status -> {
                    TransactionInfo txInfo = prepareTransactionInfo(ptm, txAttr, joinpointIdentification, status);
                    try {
                        Object retVal = invocation.proceedWithInvocation();
// --> vavr check
                        if (retVal != null && vavrPresent && VavrDelegate.isVavrTry(retVal)) {
                            // Set rollback-only in case of Vavr failure matching our rollback rules...
                            retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
                        }
                        return retVal;
                    }
                    catch (Throwable ex) {
                        ...
                    }
                    finally {
                        cleanupTransactionInfo(txInfo);
                    }
                });
            }
            catch (ThrowableHolderException ex) {
                throw ex.getCause();
            }
            catch (TransactionSystemException ex2) {
                if (throwableHolder.throwable != null) {
                    logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
                    ex2.initApplicationException(throwableHolder.throwable);
                }
                throw ex2;
            }
            catch (Throwable ex2) {
                if (throwableHolder.throwable != null) {
                    logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
                }
                throw ex2;
            }

            // Check result state: It might indicate a Throwable to rethrow.
            if (throwableHolder.throwable != null) {
                throw throwableHolder.throwable;
            }
            return result;
        }
    }

Because I have never used the Vavr library, I am very curious about these additional code logics. Is it because the Vavr library implements asynchronous mechanism different from Future or is it for other reasons.

Based on the keywords, I searched for relevant issues, and this Issue lasted for nearly 5 years, I still don’t know what makes these differences.