* @param mapper A function which creates the next {@link Deferrable} from the result of the first one.
     * Creating the invocation may be expensive, so this method avoids calling the mapper twice if possible.
     */
    default <U> Deferrable<U> flatMap(Function<? super T, Deferrable<U>> mapper) {
        return getCompleted()
            .map(mapper)
            .orElseGet(() -> Deferrable.deferred(() -> mapper

        "deferred -> deferred"   | Deferrable.deferred { 5 } | { input -> Deferrable.deferred { input + 25 } } | false           | false
        "deferred -> completed"  | Deferrable.deferred { 5 } | { input -> Deferrable.completed(input + 25) }   | false           | false
        "completed -> deferred"  | Deferrable.completed(5)   | { input -> Deferrable.deferred { input + 25 } } | false           | true

                return result;
            }
        }

        private Deferrable<Try<TransformStepSubject>> createInvocation() {
            TransformStepSubject initialSubject = TransformStepSubject.initial(artifact);
            BoundTransformStep initialStep = transformSteps.get(0);
            Deferrable<Try<TransformStepSubject>> invocation = initialStep.getTransformStep()

                if (inputArtifacts.isEmpty()) {
                    return Deferrable.completed(Try.successful(subjectToTransform.createSubjectFromResult(ImmutableList.of())));
                } else if (inputArtifacts.size() > 1) {
                    return Deferrable.deferred(() ->
                        doTransform(subjectToTransform, inputFingerprinter, dependencies, inputArtifacts)

            emitExecuteDeferredProgressDetails(work, context.getIdentity(), cacheResult);
            return Deferrable.completed(cacheResult.getResult());
        } else {
            return Deferrable.deferred(() -> {
                IdentityCacheResult<T> maybeExecutedResult = cache.get(
                    identity,
                    () -> executeInCache(work, context)
                );

import org.gradle.cache.Cache;
import org.gradle.internal.Deferrable;
import org.gradle.internal.Try;
import org.gradle.internal.execution.ExecutionEngine.IdentityCacheResult;
import org.gradle.internal.execution.UnitOfWork;
import org.gradle.internal.execution.UnitOfWork.Identity;

public interface DeferredExecutionAwareStep<C extends Context, R extends Result> extends Step<C, R> {

    /**
     * Add a configuration action to be applied to the target.
     *
     * @param runnable The action. Should be run in the order provided.
     * @param deferrable true when the action can be deferred
     */
    void addConfiguration(Runnable runnable, boolean deferrable);

    default Permits getPluginsBlockPermits() {
        return Permits.none();
    }

import org.gradle.internal.Deferrable;
import org.gradle.internal.Try;
import org.gradle.internal.execution.InputFingerprinter;

import javax.annotation.concurrent.ThreadSafe;
import java.io.File;

@ThreadSafe
public interface TransformInvocationFactory {
    /**
     * Returns an invocation which allows invoking the actual transformer.
     */
    Deferrable<Try<ImmutableList<File>>> createInvocation(

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.execution.impl;

import org.gradle.cache.Cache;
import org.gradle.internal.Deferrable;
import org.gradle.internal.Try;
import org.gradle.internal.execution.ExecutionEngine;
import org.gradle.internal.execution.UnitOfWork;
import org.gradle.internal.execution.UnitOfWork.Identity;

    }

    @Override
    public void attachScript(Script script) {
        target.setScript(script);
    }

    @Override
    public void addConfiguration(Runnable runnable, boolean deferrable) {
        if (deferrable) {
            target.addDeferredConfiguration(runnable);
        } else {
            runnable.run();
        }
    }

    @Override
    public Permits getPluginsBlockPermits() {