In the *execution phase*, Gradle runs tasks.

Gradle uses the task execution graphs generated by the configuration phase to determine which tasks to execute.

[[sec:task_execution]]

[.text-right]

    font-size: 10pt;
}

th, td {
    white-space: nowrap;
    padding-top: 5px;
    padding-bottom: 5px;
    padding-left: 12px;
    padding-right: 12px;
    text-align: left;
    vertical-align: bottom;
}

th.numeric, td.numeric {
    text-align: right;
}

.empty {
    color: #a0a0a0;
    font-size: 8pt;
}

.more-detail {
    color: #a0a0a0;
    font-size: 8pt;
}

        protected final MapCollector<K, V> right;

        private AbstractPlusCollector(MapCollector<K, V> left, MapCollector<K, V> right) {
            this.left = left;
            this.right = right;
        }

        @Override
        public ValueProducer getProducer() {
            return left.getProducer().plus(right.getProducer());
        }

        @Override

/**
 * Represents values with two possibilities.
 *
 * @param <L> the left type.
 * @param <R> the right type.
 */
public abstract class Either<L, R> {

    public static <L, R> Either<L, R> left(L value) {
        return new Left<>(value);
    }

    public static <L, R> Either<L, R> right(R value) {
        return new Right<>(value);
    }

    /**
     * Take the value if this is a left.
     */

package org.sample.numberutils;

public class Numbers {
   public static int add(int left, int right) { return left + right; }

        }
    }

    private void rerunReusingStoredConfigurationCacheEntry(List<String> args, List<String> flags) {
        // Rerun tasks. If the task is up-to-date, then its actions aren't executed.
        // This might hide issues with Groovy closures, as the methods referenced inside the closure are resolved dynamically.
        try {
            createExecuter(args, flags).withArgument("--rerun-tasks").run();

====

Now the _consumer_ needs to depend on this configuration in order to get the right artifact:

.An explicit configuration dependency
====

If your build consumes modules with Ivy metadata, you might be able to activate api and implementation separation as described <<variant_model.adoc#sub:ivy-mapping-to-variants,here>> if all modules follow a certain structure.

        def mergedSideEffect = Mock(ValueSupplier.SideEffect)

        def left = Providers.of("left").withSideEffect(leftSideEffect)
        def right = Providers.of("right").withSideEffect(rightSideEffect)

        def provider = new MergeProvider([left, right]).withSideEffect(mergedSideEffect)

        when:
        provider.calculateValue(ValueSupplier.ValueConsumer.IgnoreUnsafeRead)

        this.publications = publications;
        this.checker = checker;
        this.dependencyCoordinateResolverFactory = dependencyCoordinateResolverFactory;
        // Collect a map from component to coordinates. This might be better to move to the component or some publications model
        collectCoordinates(componentCoordinates);
    }

    public Provider<ModuleMetadataSpec> build() {