A simple reactor pattern
Intended to be used as a singleton and static with single state
Only 101% rust safe in nightly
The cycle of App methods is:
__hydrate(&mut self, _addr: A<Self>)
- enqueue message
- is ready? ->
- pop message? ->
__dispatch(&mut self, _msg: Self::Message, _addr: A<Self>)
- is queue empty? ->
__render(&mut self, _addr: A<Self>)
- is queue not empty? ->
- pop message? ->
The virtual DOM model and the difference calculation in the node tree differs from all previous implementations in many ways. The main aspect that is not found in any other implementation is that it accumulates the changes in a tree of differences equivalent space dimension is less or equal than html node tree equivalent space dimension.
It's compiled with static linking of the modules that allows to detect local fixed points at compile time and change the base of the difference linear map. That is, instead of making the difference in the html nodes, it make the difference on a tree of differences write at process line.
With what allows a reduction of the dimension of the domain and strong optimizations in parallel.
Because you don't need it because it is thinking to be implemented as singleton and static.
Because you don't need it because all uniques (mutable) references are made in atomic functions,
run! is designed for assure unique owner of all
Addr and its unique safe method
Because you don't need it because you don't need a runtime to poll wasm futures. Backpressure can be implemented for future it is needed and carry static reference to the Address of the App.
Is simpler than grow array implementation and it will never be a bottleneck in a browser. But in the future it can be implemented.
Macro to create a
DeLorean for your app. Easy and safe traveling to the future in your thread and the nightly
The address of App
Encapsulate inner context of the App
App are object which encapsulate state and behavior