1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
/*! Adapton for Rust ================ This Rust implementation embodies the latest implementation [Adapton](http://adapton.org), which offers a foundational, language-based semantics for general-purpose incremental computation. Programming model -------------------- See the Rust documentation for the following modules: - The [`macros` module](https://docs.rs/adapton/0/adapton/macros/index.html), introduces convenience macros that wrap the core interface. Its documentation gives many illustrative examples. - The [`engine` module](https://docs.rs/adapton/0/adapton/engine/index.html) gives the core programming interface. Resources --------------- - [Presentations and benchmark results](https://github.com/cuplv/adapton-talk#benchmark-results) - [IODyn: Adapton collections, for algorithms with dynamic input and output](https://github.com/cuplv/iodyn.rust) - [Adapton Lab: Evaluation and testing](https://github.com/cuplv/adapton-lab.rust) Background --------------- Adapton proposes the _demanded computation graph_ (or **DCG**), and a demand-driven _change propagation_ algorithm. Further, it proposes first-class _names_ for identifying cached data structures and computations. The following academic papers detail these technical proposals: - **DCG, and change propagation**: [_Adapton: Composable, demand-driven incremental computation_, **PLDI 2014**](http://www.cs.umd.edu/~hammer/adapton/). - **Nominal memoization**: [_Incremental computation with names_, **OOPSLA 2015**](http://arxiv.org/abs/1503.07792). - **Type and effect structures**: The draft [_Typed Adapton: Refinement types for incremental computation with precise names_](https://arxiv.org/abs/1610.00097). Why Rust? ---------- Adapton's first implementations used Python and OCaml; The latest implementation in Rust offers the best performance thus far, since (1) Rust is fast, and (2) [traversal-based garbage collection presents performance challenges for incremental computation](http://dl.acm.org/citation.cfm?doid=1375634.1375642). By liberating Adapton from traversal-based collection, [our empirical results](https://github.com/cuplv/adapton-talk#benchmark-results) are both predictable and scalable. */ #![feature(associated_consts)] #![feature(box_patterns)] #![feature(box_syntax)] #![crate_name = "adapton"] #![crate_type = "lib"] extern crate core; #[macro_use] pub mod macros ; pub mod engine ; pub mod catalog ; pub mod parse_val; pub mod reflect; mod adapton { pub use super::*; }