Spliterator<OutElementT> flatMap(
          Spliterator<InElementT> fromSpliterator,
          Function<? super InElementT, @Nullable Spliterator<OutElementT>> function,
          int topCharacteristics,
          long topSize) {
    checkArgument(
        (topCharacteristics & Spliterator.SUBSIZED) == 0,
        "flatMap does not support SUBSIZED characteristic");
    checkArgument(

        get() = analysisSchemaComponents.flatMap { it.typeDiscovery() }

    override val propertyExtractors: List<PropertyExtractor>
        get() = analysisSchemaComponents.flatMap { it.propertyExtractors() }

    override val functionExtractors: List<FunctionExtractor>
        get() = analysisSchemaComponents.flatMap { it.functionExtractors() }

        }
        val buildEnvironmentExtension = extensions.create("buildEnvironment", BuildEnvironmentExtension::class)
        buildEnvironmentExtension.gitCommitId = service.flatMap { it.gitCommitId }
        buildEnvironmentExtension.gitBranch = service.flatMap { it.gitBranch }
        buildEnvironmentExtension.repoRoot = this@with
    }

        def initial = Try.<Integer>failure(new RuntimeException("failed"))
        expect:
        initial.flatMap { it.toString() } == initial
    }

    def "failing flat map"() {
        def failure = new RuntimeException("failed")
        when:
        Try.successful(10).flatMap { throw failure }
        then:
        def ex = thrown Exception
        ex == failure
    }

    def "map a failure"() {

val copyGr8OutputJarAsGradleWrapperJar by tasks.registering(Copy::class) {
    from(tasks.named<Gr8Task>("gr8R8Jar").flatMap { it.outputJar() })
    into(layout.buildDirectory.dir("libs"))
}

tasks.jar {
    from(tasks.named<Gr8Task>("gr8R8Jar").flatMap { it.outputJar() })
    dependsOn(copyGr8OutputJarAsGradleWrapperJar)

    fun applyAssignmentConventions(
        referencedSoftwareTypes: List<SoftwareTypeConventionResolutionResults>
    ): List<AssignmentRecord> =
        referencedSoftwareTypes.flatMap { softwareType ->
            softwareType.assignments.map { assignmentRecord ->
                assignmentRecord.copy(

            .flatMap(it -> it.contributeClassLevelAnnotationTypes().stream())
            .collect(Collectors.toSet());
    }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        Stream<? extends Element> annotatedTypes = getSupportedAnnotations().stream()
            .flatMap(annotation -> roundEnv.getElementsAnnotatedWith(annotation).stream())

    }

    override fun getAllClassesByClassId(classId: ClassId): Collection<KtClassOrObject> {
        return providers.flatMap { it.getAllClassesByClassId(classId) }
    }

    override fun getAllTypeAliasesByClassId(classId: ClassId): Collection<KtTypeAlias> {
        return providers.flatMap { it.getAllTypeAliasesByClassId(classId) }
    }

            "SOFTWARE\\Wow6432Node\\JavaSoft\\Java Development Kit",
            "SOFTWARE\\Wow6432Node\\JavaSoft\\Java Runtime Environment"
        ).stream().map(this::findJvms).flatMap(List::stream);
        return Stream.concat(openJdkInstallations, jvms)
            .map(javaHome -> InstallationLocation.autoDetected(new File(javaHome), getSourceName()))
            .collect(Collectors.toSet());
    }

        get() = PerformanceTestType.adHoc

    override
    val failsStage: Boolean
        get() = false

    val buildSpecs: List<FlameGraphGenerationBuildSpec>
        get() = scenarios.flatMap { scenario ->
            Os.values().flatMap { os ->
                val arch = if (os == Os.MACOS) Arch.AARCH64 else Arch.AMD64
                if (os == Os.WINDOWS) {
                    listOf("jprofiler")
                } else {