Method apply

src/simplify_algebra.cpp:1367–1466

    }

    void apply(module& m, const match::matcher_result& r) const
    {
        auto ins    = r.result;
        auto splits = get_splits(ins);
        if(splits.empty())
            return;
        auto split_groups = get_split_groups(m, ins, splits);
        if(split_groups_are_dependent(m, ins, split_groups))
        {
            return;
        }

        for(const auto& group : split_groups)
        {
            auto start       = group.front();
            auto split_front = splits.front();
            auto op          = start->get_operator();
            if(not is_fusable(start, split_front))
            {
                continue;
            }

            // Make sure there are no duplicates
            assert(std::none_of(
                std::next(group.begin()), group.end(), [&](auto i) { return i == start; }));

            auto split_idx    = 0;
            instruction_ref c = m.end();
            if(start->inputs().size() == 1)
            {
                c = m.insert_instruction(std::next(ins), op, {ins}, start->module_inputs());
            }
            else if(start->inputs().size() == 2)
            {
                assert(not std::none_of(start->inputs().begin(), start->inputs().end(), [](auto i) {
                    return i->name() == "slice";
                }) and "one argument must be a split");

                auto slice_op = any_cast<op::slice>(splits.front()->get_operator());
                assert(not slice_op.axes.empty());
                if(slice_op.axes.size() > 1)
                    return;
                auto concat_axis = slice_op.axes.front();
                if(not concat_const_foldable(group.begin(), group.end(), concat_axis))
                    return;

                split_idx = get_binary_op_split_idx(group, splits);
                assert(split_idx < 2);
                size_t data_idx;
                if(split_idx < 0 and op.attributes().contains("commutative"))
                {
                    split_idx = 0;
                    data_idx  = 1;
                    align_commutative_op_args(m, group, splits, split_idx);
                }
                else if(split_idx < 0)
                {
                    return;