This module consists of rules for fusion that involves WithAcc constructs. Currently, we support two non-trivial transformations: I. SOAC-through-Trans-into-WithAcc fusion: a SoacNode is fused into a WithAcc atomically when all dependency paths between them go through TransNodes (reshapes/rearranges) that have no other consumers. The canonical example is a map nest producing multi-dimensional index and value arrays that are flattened and consumed by a scatter. This must be done atomically to avoid an infinite loop: absorbing only the TransNode causes simplifyLambda to hoist the cheap reshape back out, recreating the same TransNode and triggering the rule again. The strategy is to prepend the SoacNode and all TransNode statements into the WithAcc lambda body and run doFusionInLambda to fuse further where possible.

II. WithAcc-WithAcc fusion: two withaccs can be fused as long as the common accumulators use the same operator, and as long as the non-accumulator input of an WithAcc is not used as an accumulator in the other. This fusion opens the door for fusing the SOACs appearing inside the WithAccs. This is also intended to demonstrate that it is not so important where exactly the WithAccs were originally introduced in the code, it is more important that they can be transformed by various optimizations passes.