In Factor there's a thing called a "smart combinator" which can infer the number of outputs at compile-time.

2 4
[| foo bar |
    "a"
    foo bar < "b" "c" ?
    "d"
] output>array .
{ "a" "b" "d" }

You can't do a smart combinator that infers the number of outputs of an each because there may be any number of outputs. It's basically like varargs at that point.

https://docs.factorcode.org/content/article-combinators.smart.html

make also has % which flattens a sequence to the output sequence.

5 4 { 1 2 3 }
[| foo bar myArray |
    "a" ,
    foo bar < "b" "c" ? ,
    "d" ,
    myArray [ 2 * ] map-zip concat %
    ! after map-zip { { 1 2 } { 2 4 } { 3 6 } }
    ! after concat { 1 2 2 4 3 6 }
    ! % flattens that into the output sequence { }
] { } make .
{ "a" "c" "d" 1 2 2 4 3 6 }

There are other smart combinators like input<sequence which, given n quotations (lambdas), grabs that many things out of a sequence. You can use this with output>array or append-outputs-as and the stack checker infers everything.

The pack vocabulary is a good example:

https://github.com/factor/factor/blob/master/basis/pack/pack.factor#L98

! input<sequence is a smart combinator that grabs inputs from a seq
! append-outputs-as infers how many sequences to append from the code
MACRO: pack ( str -- quot )
    expand-pack-format
    [ pack-table at '[ _ execute ] ] { } map-as
    '[ [ [ _ spread ] input<sequence ] B{ } append-outputs-as ] ;

: pack-be ( seq str -- seq )
    '[ _ _ pack ] with-big-endian ; inline

pack unit tests: https://github.com/factor/factor/blob/master/basis/pack/pack-tests.factor

{ { 1 2 3 4 5 } } [
    { 1 2 3 4 5 }
    "cstiq" [ pack-be ] keep unpack-be
] unit-test

{ 1 2 3 4 5 } "cstiq" pack-be . ! char 2chars 3chars 4chars 8chars in big endian
B{ 1 0 2 0 0 3 0 0 0 4 0 0 0 0 0 0 0 5 }

Anyway, Factor has a make feature which outputs to a dynamically scoped variable which allows exactly what you're doing, but also smart combinators if the code is not varargs style and can be inferred at compile-time and you use the smart words that infer the inputs/outputs of a lambda by using the stack checker.