Consider creating a builder class for constructing circuits?

[tanujkhattar]

Description of the issue
We have often discussed in the past the need for a builder pattern for constructing circuits, for example see #3246 and #2775.

#6013 made a first attempt of abstracting out an important piece of circuit construction code into a free function - get_earliest_accommodating_moment_index.

This issue to discuss:

1. Where to best put the free function get_earliest_accommodating_moment_index.
2. Create a new circuit builder class that can generalize the utility provided by get_earliest_accommodating_moment_index and can be used in both Circut._load_contents_with_earliest_strategy and _stratify_circuit for efficiently constructing new circuits.

Cirq version

1.2.0.dev

[verult]

From Cirq sync:

• Interop with existing Circuit/AbstractCircuit/FrozenCircuit could be tricky and needs careful consideration
• Could potentially be a Cirq 2.0 feature

[daxfohl]

Circuit constructor is efficient when passed a list of operations, so

1. Is List[Op] sufficient as a builder? Is there anything more that a custom builder type would need to do?

Also, the constructor is efficient because it maintains a temp data structure that allows for appends to be efficient, and then it constructs the circuit by appending each op one-by-one. So

2. Should we maintain that temp data structure as a member of Circuit, and, so long as only append is used, we keep the data structure fresh? (As soon as something other than append is used, we can clear the data structure and revert back to the inefficient method).

From what I've seen, most people seem just to use append all the time, probably unaware that the List[Op] constructor is much more efficient. So that seems like low-hanging fruit with high ROI. Should be a fairly easy PR, just changing a local cache to a member cache, and clearing it when non-append modifiers are used. Could be a good first issue.

[daxfohl]

#6882 would do part 2 above

[daxfohl]

Also, given that Circuit(List[Op]) is more efficient than repeated circuit.append(...), even after optimizations, should the notebooks be updated to use that approach? Most users' code I've seen seems to go with the append approach. My hunch is users start off by copying what's in the notebooks, and don't realize it's inefficient for large circuits.