return delegate.map(mapper);
    }

    @SuppressWarnings({"RedundantCast", "unchecked"})
    public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper) {
        return delegate.flatMap((Function<T, Optional<U>>) mapper);
    }

    public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier) {
        Objects.requireNonNull(supplier);

    sources copyTemplates
}
// end::task-arg-method[]

// tag::failed-inferred-task-dep[]

tasks.register('badInstrumentClasses', Instrument) {
    classFiles.from fileTree(tasks.named('compileJava').flatMap { it.destinationDirectory }) {}
    destinationDir = file(layout.buildDirectory.dir('instrumented'))
}
// end::failed-inferred-task-dep[]

// tag::inferred-task-dep[]
tasks.register('instrumentClasses', Instrument) {

    sources(copyTemplates)
}
// end::task-arg-method[]

// tag::failed-inferred-task-dep[]

tasks.register<Instrument>("badInstrumentClasses") {
    classFiles.from(fileTree(tasks.compileJava.flatMap { it.destinationDirectory }))
    destinationDir = layout.buildDirectory.dir("instrumented")
}
// end::failed-inferred-task-dep[]

// tag::inferred-task-dep[]
tasks.register<Instrument>("instrumentClasses") {

                    jarOutputStream.addJarEntry(relativePath, it)
                }
            }
        }
    }

    private
    fun readEntryPoints() = entryPointsConfiguration.files.flatMap { readJson<List<String>>(it) }

    private
    fun readClassTrees() = classTreesConfiguration.files.map { readJson<Map<String, List<String>>>(it) }

    private

}
tasks.register('consumer', Consumer) {
    // Connect the producer task output to the consumer task input
    // Don't need to add a task dependency to the consumer task. This is automatically added
    message = producer.flatMap { it.outputFile }.map { it.asFile.text }

        val declarationGenerators = session.extensionService.declarationGenerators

        val generatedTopLevelClassifiers = declarationGenerators
            .asSequence()
            .flatMap {
                // FIXME this function should be called only once during plugin's lifetime, so this usage is not really correct (2)
                it.getTopLevelClassIds()
            }

            task.setGroup("release notes");
            task.setDescription("Transforms generated release notes.");

            task.getHtmlFile().convention(releaseNotesMarkdown.flatMap(RenderMarkdown::getDestinationFile));
            task.getBaseCssFile().convention(extension.getReleaseNotes().getBaseCssFile());
            task.getReleaseNotesCssFile().convention(extension.getReleaseNotes().getReleaseNotesCssFile());

sealed interface ElementResult<out T : LanguageTreeElement> : LanguageResult<T> {
    fun <R : LanguageTreeElement> flatMap(mapping: (T) -> ElementResult<R>): ElementResult<R> = when (this) {
        is Element -> mapping(element)
        is FailingResult -> this
    }
}


sealed interface SyntacticResult<out T> : LanguageResult<T> {
    fun <R> flatMap(mapping: (T) -> SyntacticResult<R>): SyntacticResult<R> = when (this) {

        return controller.getBuildModel().getEditableBuilds().stream()
            .map(build -> controller.getModel(build.getRootProject(), BuildInvocations.class))
            .flatMap(invocations -> invocations.getTasks().stream())
            .collect(toList());
    }

consumer.configure {
    // Connect the producer task output to the consumer task input
    // Don't need to add a task dependency to the consumer task. This is automatically added
    inputFile = producer.flatMap { it.outputFile }
}

producer.configure {
    // Set values for the producer lazily
    // Don't need to update the consumer.inputFile property. This is automatically updated as producer.outputFile changes