moduleIdSetsExcludes = ImmutableList.of(delegate.moduleIdSet(moduleIdSetsExcludes.stream().flatMap(e -> e.getModuleIds().stream()).collect(toSet())));
        }
        if (groupSetExcludes.size() > 1) {
            groupSetExcludes = ImmutableList.of(delegate.groupSet(groupSetExcludes.stream().flatMap(e -> e.getGroups().stream()).collect(toSet())));
        }
        if (moduleSetExcludes.size() > 1) {

            is ErrorType -> return emptyList()
            is CapturedType -> return type.constructor.supertypes.flatMap { getUpperBounds(it) }
            is NewCapturedType -> return type.constructor.supertypes.flatMap { getUpperBounds(it) }
            is SimpleType -> {
                val typeParameterDescriptor = TypeUtils.getTypeParameterDescriptorOrNull(type)

    }

    @Override
    public R execute(UnitOfWork work, C context) {
        Identity identity = context.getIdentity();
        PreviousExecutionState previousExecutionState = context.getHistory()
            .flatMap(history -> history.load(identity.getUniqueId()))
            .orElse(null);
        R result = delegate.execute(work, new PreviousExecutionContext(context, previousExecutionState));

        this.delegate = delegate;
    }

    @Override
    protected Optional<HashCode> getPreviousCacheKeyIfApplicable(C context) {
        return context.getChanges()
            .flatMap(changes -> context.getPreviousExecutionState()
                .filter(__ -> changes.getChangeDescriptions().isEmpty())
                .map(PreviousExecutionState::getCacheKey));
    }

    @Override

    public static <T> BindingInitializer<T> combine(List<BindingInitializer<T>> bindingInitializers) {
        Set<Key<?>> deps = bindingInitializers.stream()
                .map(BindingInitializer::getDependencies)
                .flatMap(Collection::stream)
                .collect(toSet());
        return new BindingInitializer<T>(deps) {
            @Override
            public Consumer<T> compile(Function<Key<?>, Supplier<?>> compiler) {

    private val buckets: Map<TestCoverage, List<BuildTypeBucket>> by lazy {
        val uuidToTestCoverage = model.stages.flatMap { it.functionalTests }.associateBy { it.uuid }
        val testCoverageAndBuckets = JSON.parseArray(testBucketsJson.readText()) as JSONArray
        testCoverageAndBuckets.associate { testCoverageAndBucket ->

        val pairs = durations.flatMap { it ->
            val scenarioDurations = it as JSONObject
            val scenario = Scenario.fromTestId(scenarioDurations["scenario"] as String)
            (scenarioDurations["durations"] as JSONArray).flatMap {
                val duration = it as JSONObject
                val testProject = duration["testProject"] as String

    }

    private PatternSet getNewGeneratedClasses(ApiCompilerResult result) {
        PatternSet filesToDelete = fileOperations.patternSet();
        result.getSourceClassesMapping().values().stream()
            .flatMap(Collection::stream)
            .forEach(className -> {
                filesToDelete.include(className.replace(".", "/").concat(".class"));
                filesToDelete.include(className.replaceAll("[.$]", "_").concat(".h"));

    isTransitive = false
    extendsFrom(manifestClasspath.get())
    configureAsRuntimeJarClasspath(objects)
}

tasks.jar.configure {
    val classpath = resolveManifestClasspath.flatMap { configuration ->
        configuration.elements.map { classpathDependency ->
            classpathDependency.joinToString(" ") { it.asFile.name }
        }
    }
    manifest.attributes("Class-Path" to classpath)

        def transformer = Mock(Transformer)

        given:
        def provider = providerWithValue(someValue())

        when:
        def mapped = provider.flatMap(transformer)

        then:
        0 * _

        when:
        def present = mapped.present

        then:
        present

        and: