Type(...)-directive for multiple inputs

Hello everyone. While I was trying to experiment with the custom assembly formats of operations with a number of operands where some specific subsets of the whole operand set share a type among its elements, I found out it could be quite comfortable to be able to specify each subset’s common type only once without the need of repeating again and again for each operand of the chosen subset.

Specifically, here is a glimpse of a custom assembly format for a simple multiplexer and operands for it:

let arguments = (ins
let assemblyFormat = "`(` $control `,` $first `,` $second (`,` $others^ )? `)` attr-dict";
let results = (outs Stream:$res);

Each Stream-type has to be parametrized, so we need to specify the types ourselves, but the $control-stream type might be different from the type of all the other streams, thus we cannot use SameOperandsAndResultType-traits and such.

So what I would like to do is to discard the most evident way to describe such an assembly format

let assemblyFormat = "`(` $control `:` type($control) `,` $first `:` type($first) `,` $second `:` type($second) (`,` $others^ `:` type($others) )? `)` attr-dict `:` type($res)";

and use something more convenient like

let assemblyFormat = "`(` $control `:` type($control) `,` $first `,` $second (`,` $others^ )? `)` attr-dict `:` type($first, $second, $others, $res)";

Is it possible in any way to use a notation like that without the need to use some specialized Traits?

P.S. By the way, I would like to ask if there are any up-to-date reference pages for the usage of Traits, as to my knowledge, the main Traits-page does not even cover the abovementioned SameOperandsAndResultType-trait and some others.

What do you expect this should print?

The way I understand it, the type-directive allows us to put constraints on buildable types being used, otherwise rises a problem of type inference. By using the directive I expect the output be the same as with a singular argument - its type, it’s just that the type is being used by a number of operands at the same time.