The main reason for allowing multiple produce methods at once was that primitive could expose multiple "views" on same results. This was motivated by clustering primitives which might want to return a membership for input samples, or a distance matrix. But it seems it makes it unnecessary complicated to code this efficiently for this motivating example (and currently main use case). The issue is that primitive does not know in advance that a TA2 will call two produce methods so in simple implementation it would have to recompute data twice (which means we could simply have two primitives each having one produce method). Or it can try to cache things (but this makes it break the idea that transformers do not have state). And even with caching is tricky to know when have you been feed same inputs (to use cache) and when not. It can be expansive to do equality check on inputs. You might even not want to cache inputs themselves. One question here is how much difference in arguments different produce methods of the same primitive are getting? Currently we allow each method to have different argument (except for required arguments). But is this flexibility really needed? If not, one approach to address this issue would be that we remove multiple produce methods and have an extra standard argument to one produce method telling which outputs you want. For example: ```python primitive.produce(inputs=inputs, outputs=('mapping', 'distance_matrix'), ...) ``` And then `call_result` could have `result['mapping']` `result['distance_matrix']`, for example. By default it would have only `call_result['outputs']`. (Instead of current result.value`.) If we want to allow each produce method to get their own arguments, and if we want to allow backwards compatibility, we can instead introdocue additional method, like: ``` primitive.multi_produce({'produce': produce_arguments, 'produce_distance_matrix': distance_matrix_arguments) ``` And the output would be a dict of cal results. Default implementation would just call them in order. But optimized primitive could reimplement the method to compute things more efficiently. Implementation would still have to compare which arguments to which method is equal, but this can be simply a referential equality at this point. So if same ndarray is passed to each set of arguments, you can just do `array1 is array2` to check if they are equal.