loop through process in dsl2

[tomSimonet]

Hello
I tried to repeat in dsl2 the dsl1 example: https://github.com/nextflow-io/patterns/blob/master/docs/feedback-loop.adoc
but failed:

#!/usr/bin/env nextflow

nextflow.enable.dsl=2

params.input = 'hello.txt'

process foo {
    input:
    path(x)
    output:
    path('foo.txt')
    script:
    """
    cat $x > foo.txt
    """
}

process bar {
    input:
    path(x)
    output:
    path('bar.txt'), emit: feedback
    path('bar.txt'), emit: result
    script:
    """
    cat $x > bar.txt
    echo World >> bar.txt
    """
}

workflow {

    condition = { it.readLines().size()>3 }

    input_ch = Channel.fromPath(params.input).mix( bar.out.feedback.until(condition) )

    foo(input_ch) | bar

    bar.out.result.view( { "Result:\n${it.text.indent(' ')}" } )

}

gives me:

progr/nextflow-21.10.4-all run hcl_nextflow/Scripts/test_loop.nf 
N E X T F L O W  ~  version 21.10.4
Launching `hcl_nextflow/Scripts/test_loop.nf` [disturbed_cori] - revision: 20fd914668
Access to 'bar.out' is undefined since process doesn't declare any output

 -- Check script 'hcl_nextflow/Scripts/test_loop.nf' at line: 36 or see '.nextflow.log' file for more details

and removing the loop (comment before .mix( :

[e0/254799] process > foo (1) [100%] 1 of 1 ✔
[7b/98f8bb] process > bar (1) [100%] 1 of 1 ✔
Result:
 hello
 World

Is there another way to achieve this?
practically, I would need it in order to use the same process several times, taking the output as input (some vcfs), except for the database that would change each time
eg:

workflow bdd_annotation_loop {
    take:
        input_vcf    //tuple : [info1, info2, info3, vcf]
        bdds          // tuple of collections: [ [bdd1,index1,tag1,field1], [bdd2,index2,tag2,field2], ...]

    main:
        input_ch = input_vcf.concat( bdds.map{it[0]}, Channel.of(0) ).flatten().toList()
                    .mix(
                        Annotation_bdd_vcf.out
                            .concat( bdds )
                            .toList()
                            .map { ch_tuple, bdds ->
                                if ( ch_tuple[4] < bdds.size() ) { //(bdds[iteration]) {
                                    return [ ch_tuple[0], ch_tuple[1], ch_tuple[2], ch_tuple[3], bdds[iteration], ch_tuple[4] ].flatten()
                                }
                            }
                    )
        Annotation_bdd_vcf( input_ch )

}

the Annotation_bdd_vcf process increment a variable (the last one in input, coming from Channel.of(0)) each time, and return it (index4 of tuple)

sorry if silly question!!

[pditommaso]

There's an on-going development to allow this pattern with DSL2. I'll provide some update in a few days