pinky

sically simplifying a little bit for each component (CPU, PPU, APU, etc.): 1. You put the whole state of the component into a separate `State` structure. 2. You create a `Context` trait which has a `get_state`/`get_state_mut` method as well as various callbacks needed by the component itself (e.g. PPU's `Context` has a `peek_video_memory` so that it can read video memory which is stored externally). 3. You create an `Interface` trait (with `Context` as supertrait) which contains the public interface of a given component (e.g. PPU has `execute`, `peek_ppustatus`, etc.). 4. You put the whole implementation of the component inside of a `Private` trait (with `Context` as supertrait). 5. You do a blanket impl of `Interface` and `Private` for any `T` which implements `Context`. So then you create a single `Nes` structure which has `cpu::State`, `ppu::State`, etc. inside of it as fields, and implements the `cpu::Context`, `ppu::Context`, etc. traits. Inside of those impls you just wire the various subcomponents together, and voila, every component is encapsulated from each other and yet they can talk with each other, and there is no indirection anywhere (no `Box`es, no `RefCell`s, etc.).