Method apply

src/simplify_algebra.cpp:1481–1540

    }

    void apply(module& m, const match::matcher_result& r) const
    {
        // Verifies that the slices meet several conditions: they must all output to the same
        // concat instruction, slice on the same (1 only) axis, and the end of one slice
        // must match the start of the next.
        auto ins = r.result;

        auto splits = get_splits(ins);
        if(splits.empty())
            return;
        // Each slice must output to only one instruction
        if(std::any_of(
               splits.begin(), splits.end(), [](auto i) { return i->outputs().size() != 1; }))
            return;
        // The single output instruction for all items in the list must be the same one
        auto concat = splits.front()->outputs().front();
        if(std::any_of(splits.begin(), splits.end(), [&](auto i) {
               return i->outputs().front() != concat;
           }))
            return;

        // The axis for the common output instruction must be the same as for the split ops
        auto concat_op = any_cast<op::concat>(concat->get_operator());
        auto split_op  = any_cast<op::slice>(splits.front()->get_operator());
        if(split_op.axes.size() != 1)
            return;
        if(split_op.axes.front() != concat_op.axis)
            return;

        // Find where the slices are in the concat instruction's inputs (concat can have
        // any number of inputs)
        auto args = concat->inputs();
        auto it =
            std::find_if(args.begin(), args.end(), [&](auto i) { return i == splits.front(); });
        // Verify the slices were found, and the list is long enough
        if(std::distance(it, args.end()) < splits.size())
            return;
        // Don't do anything if the "slice" inputs to the concat op have other operations mixed in
        // among them
        if(std::any_of(it, it + splits.size(), [](instruction_ref x) {
               return x->get_operator().name() != "slice";
           }))
            return;
        // Check that the slices passed to concat are in order.
        if(not std::is_sorted(it, it + splits.size(), [](instruction_ref x, instruction_ref y) {
               auto xop = any_cast<op::slice>(x->get_operator());
               auto yop = any_cast<op::slice>(y->get_operator());
               return std::tie(xop.starts, xop.ends) < std::tie(yop.starts, yop.ends);
           }))
            return;

        // Perform the substitution
        *it = splits.front()->inputs().front();
        args.erase(std::next(it), it + splits.size());

        if(args.size() == 1)
            m.replace_instruction(concat, args.front());
        else