Idea to overload combinedWith without the combination function

[geniusit]

Sometime, I don't need the combination function params provided by the combinedWith function.

I have two samples :

 return
                    Uni
                            .combine()
                            .all()
                            .unis(
                                    karmFiles
                                            .stream()
                                            .map(
                                                    karmFile ->
                                                            SuperChargeurUtils
                                                                    .processError(
                                                                            s3Context,
                                                                            karmFile.getPayload(),
                                                                            karmFile.getFileName(),
                                                                            e.getMessage(),
                                                                            e.getShortMessage()
                                                                    )
                                            )
                                            .toList()
                            )
                            .combinedWith(unis -> //why not  () ?
                                    Collections.singletonList(
                                            SuperChargeurResult.build(folderName, e.getShortMessage())
                                    )
                            )
                            .invoke(() -> log.error(e.getMessage()))
                    ;

and

@GET
    @Path("/clean-raw")
    public Uni<RestResponse<String>> getObjectss(
            @RestQuery("provider") final String provider
    ) {
        return
                Objects.isNull(provider)
                        ?
                        Uni.createFrom().item(RestResponse.status(RestResponse.Status.BAD_REQUEST))
                        :
                        Multi
                                .createBy()
                                .repeating()
                                .uni(
                                        () -> new AtomicReference<String>(),
                                        state ->
                                                ConnectorUtils
                                                        .listObjectsV2Async(
                                                                s3Context.getS3AsyncClient(),
                                                                s3Context.getBucket(),
                                                                "projets/EQS/dqmp/VOYAGEURS/gold/PDA-REQ/data_files/ReleveMR_EvtDecodeEQS_VOYAGEURS_DQMP/DECODED/raw/kvb/" + provider + "/",
                                                                state.get()
                                                        )
                                                        .chain(response ->

                                                                Uni
                                                                        .combine()
                                                                        .all()
                                                                        .unis(
                                                                                response
                                                                                        .contents()
                                                                                        .stream()
                                                                                        .map(s3Object ->
                                                                                                ConnectorUtils
                                                                                                        .deleteObjectAsync(
                                                                                                                s3Context.getS3AsyncClient(),
                                                                                                                s3Context.getBucket(),
                                                                                                                s3Object.key()
                                                                                                        )
                                                                                        )
                                                                                        .collect(Collectors.toList())
                                                                        )
                                                                        .combinedWith(onsenfou -> {

                                                                            state.set(response.nextContinuationToken());
                                                                            return response;
                                                                        })
                                                        )
                                                        .invoke(
                                                                listObjectsV2Response -> state.set(listObjectsV2Response.nextContinuationToken())
                                                        )
                                )
                                .whilst(listObjectsV2Response ->
                                        StringUtils.isNotEmpty(listObjectsV2Response.nextContinuationToken())
                                )
                                .toUni()
                                .chain(
                                        () ->
                                                Uni
                                                        .createFrom()
                                                        .item(RestResponse.ok())
                                )
                ;
    }

As you can see, I don't need the combination function. Is is a good idea to overload the combinedWith method? Or may be an other mecanism is more suitable in that situation ?

Thank you

[jponge]

You might use Uni.join() for that purpose.