* the {@code Try} representing the original failure.
     *
     * Exceptions thrown by the given function are propagated.
     */
    public abstract <U> Try<U> flatMap(Function<? super T, Try<U>> f);

    /**
     * If the represented operation was successful, returns the result of applying the given
     * mapping function to the value, otherwise returns

                                            .flatMap(phase -> phase.plugins().stream())
                                            .toList())
                                    .build()));
            Map<Plugin, Plugin> allPlugins = new LinkedHashMap<>();
            plugins.values().stream().flatMap(pc -> pc.getPlugins().stream()).forEach(p -> addPlugin(allPlugins, p));

        public fun resolveKdocFqName(analysisSession: KaSession, fqName: FqName, contextElement: KtElement): Collection<KaSymbol> =
            EP_NAME.extensions.flatMap { it.resolveKdocFqName(analysisSession, fqName, contextElement) }
    }

                return new CompositeFileSystemSnapshot(snapshots);
        }
    }

    @Override
    public Stream<FileSystemLocationSnapshot> roots() {
        return snapshots.stream()
            .flatMap(FileSystemSnapshot::roots);
    }

    @Override
    public SnapshotVisitResult accept(FileSystemSnapshotHierarchyVisitor visitor) {
        for (FileSystemSnapshot snapshot : snapshots) {

        it.stageName in listOf(
            StageName.QUICK_FEEDBACK_LINUX_ONLY,
            StageName.QUICK_FEEDBACK,
            StageName.PULL_REQUEST_FEEDBACK,
            StageName.READY_FOR_NIGHTLY,
        )
    }.flatMap { it.functionalTests }.filter { it.os == os }

    if (os == Os.LINUX) {
        steps {
            script {

            }

            tasks.register('consumer', ConcatTask) {
                // Create a complex file collection chain involving `flatMap`, `map` and `filter`
                Provider<RegularFile> producerOutputFile = producer.flatMap { it.outputFile }
                Provider<List<RegularFile>> mappedOutputFile = producerOutputFile.map { [it] }

        println(sourceFragment.replaceIndent("    "))
        println()
    }
}


private
fun accessorSourceFragmentsFor(schema: TypedProjectSchema): Sequence<String> =
    accessorsFor(schema.map(::accessible)).flatMap { accessor ->
        val (_, fragments) = fragmentsFor(accessor)
        fragments
            .map { it.source }
            .filter { it.isNotBlank() }

    }

    @Override
    public Map<PerformanceExperimentOnOs, Long> getEstimatedExperimentDurationsInMillis() {
        return stores.stream()
            .flatMap(store -> store.getEstimatedExperimentDurationsInMillis().entrySet().stream())
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, Math::max, LinkedHashMap::new));
    }

            classFileManagerType = Optional.of(TransactionalManagerType.of(spec.getClassfileBackupDir(), new SbtLoggerAdapter()));
        }

        PreviousResult previousResult = analysisStore.flatMap(store -> store.get()
            .map(a -> PreviousResult.of(Optional.of(a.getAnalysis()), Optional.of(a.getMiniSetup()))))
            .orElse(PreviousResult.of(Optional.empty(), Optional.empty()));

        if (os.isLinux()) {
            return Arrays.stream(roots)
                .map(root -> FileBasedInstallationFactory.fromDirectory(root, getSourceName(), InstallationLocation::autoDetected))
                .flatMap(Set::stream)
                .collect(Collectors.toSet());
        }
        return Collections.emptySet();
    }