Remove additional examples

Author: Darin Morrison

text/0000-type-macros.md

@@ -43,9 +43,7 @@ case for the `Ty_` enum so that the parser can indicate a macro
 invocation in a type position. In other words, `TyMac` is added to the
 ast and handled analogously to `ExprMac`, `ItemMac`, and `PatMac`.
 
-## Examples
-
-### Heterogeneous Lists
+## Example: Heterogeneous Lists
 
 Heterogeneous lists are one example where the ability to express
 recursion via type macros is very useful. They can be used as an
@@ -136,7 +134,7 @@ Operations on HLists can be defined by recursion, using traits with
 associated type outputs at the type-level and implementation methods
 at the term-level.
 
-The HList append operation is provided as an example. type macros are
+The HList append operation is provided as an example. Type macros are
 used to make writing append at the type level (see `Expr!`) more
 convenient than specifying the associated type projection manually:
 
@@ -191,236 +189,6 @@ fn test_append() {
 }
 ```
 
-### Additional Examples ###
-
-#### Type-level numerics
-
-Type-level numerics are another area where type macros can be
-useful. The more common unary encodings (Peano numerals) are not
-efficient enough to use in practice so we present an example
-demonstrating binary natural numbers instead:
-
-```rust
-struct _0; // 0 bit
-struct _1; // 1 bit
-
-// classify valid bits
-trait Bit: MarkerTrait {}
-impl Bit for _0 {}
-impl Bit for _1 {}
-
-// classify positive binary naturals
-trait Pos: MarkerTrait {}
-impl Pos for _1 {}
-impl<B: Bit, P: Pos> Pos for (P, B) {}
-
-// classify binary naturals with 0
-trait Nat: MarkerTrait {}
-impl Nat for _0 {}
-impl Nat for _1 {}
-impl<B: Bit, P: Pos> Nat for (P, B) {}
-```
-
-These can be used to index into tuples or HLists generically, either
-by specifying the path explicitly (e.g., `(a, b, c).at::<(_1, _0)>()
-==> c`) or by providing a singleton term with the appropriate type
-`(a, b, c).at((_1, _0)) ==> c`. Indexing is linear time in the general
-case due to recursion, but can be made constant time for a fixed
-number of specialized implementations.
-
-Type-level numbers can also be used to define "sized" or "bounded"
-data, such as a vector indexed by its length:
-
-```rust
-struct LengthVec<A, N: Nat>(Vec<A>);
-```
-
-Similar to the indexing example, the parameter `N` can either serve as
-phantom data, or such a struct could also include a term-level
-representation of N as another field.
-
-In either case, a length-safe API could be defined for container types
-like `Vec`. "Unsafe" indexing (without bounds checking) into the
-underlying container would be safe in general because the length of
-the container would be known statically and reflected in the type of
-the length-indexed wrapper.
-
-We could imagine an idealized API in the following fashion:
-
-```rust
-// push, adding one to the length
-fn push<A, N: Nat>(xs: LengthVec<A, N>, x: A) -> LengthVec<A, N + 1>;
-
-// pop, subtracting one from the length
-fn pop<A, N: Nat>(xs: LengthVec<A, N + 1>, store: &mut A) -> LengthVec<A, N>;
-
-// look up an element at an index
-fn at<A, M: Nat, N: Nat, P: M < N>(xs: LengthVec<A, N>, index: M) -> A;
-
-// append, adding the individual lengths
-fn append<A, N: Nat, M: Nat>(xs: LengthVec<A, N>, ys: LengthVec<A, M>) -> LengthVec<A, N + M>;
-
-// produce a length respecting iterator from an indexed vector
-fn iter<A, N: Nat>(xs: LengthVec<A, N>) -> LengthIterator<A, N>;
-```
-
-We can't write code like the above directly in Rust but we could
-approximate it through type-level macros:
-
-```rust
-// Expr! would expand + to Add::Output and integer constants to Nat!; see
-// the HList append earlier in the RFC for a concrete example
-Expr!(N + M)
-    ==> <N as Add<M>>::Output
-
-// Nat! would expand integer literals to type-level binary naturals
-// and be implemented as a plugin for efficiency; see the following
-// section for a concrete example
-Nat!(4)
-    ==> ((_1, _0), _0)
-
-// `Expr!` and `Nat!` used for the LengthVec type:
-LengthVec<A, Expr!(N + 3)>
-    ==> LengthVec<A, <N as Add< Nat!(3)>>::Output>
-    ==> LengthVec<A, <N as Add<(_1, _1)>>::Output>
-```
-
-##### Implementation of `Nat!` as a plugin
-
-The following code demonstrates concretely how `Nat!` can be
-implemented as a plugin. As with the `HList!` example, this code (with
-some additions) compiles and is usable with the type macros prototype
-in the branch referenced earlier.
-
-For efficiency, the binary representation is first constructed as a
-string via iteration rather than recursively using `quote` macros. The
-string is then parsed as a type, returning an ast fragment.
-
-```rust
-// Convert a u64 to a string representation of a type-level binary natural, e.g.,
-//     ast_as_str(1024)
-//         ==> "(((((((((_1, _0), _0), _0), _0), _0), _0), _0), _0), _0)"
-fn ast_as_str<'cx>(
-        ecx: &'cx base::ExtCtxt,
-    mut num: u64,
-       mode: Mode,
-) -> String {
-    let path = "_";
-    let mut res: String;
-    if num < 2 {
-        res = String::from_str(path);
-        res.push_str(num.to_string().as_slice());
-    } else {
-        let mut bin = vec![];
-        while num > 0 {
-            bin.push(num % 2);
-            num >>= 1;
-        }
-        res = ::std::iter::repeat('(').take(bin.len() - 1).collect();
-        res.push_str(path);
-        res.push_str(bin.pop().unwrap().to_string().as_slice());
-        for b in bin.iter().rev() {
-            res.push_str(", ");
-            res.push_str(path);
-            res.push_str(b.to_string().as_slice());
-            res.push_str(")");
-        }
-    }
-    res
-}
-
-// Generate a parser which uses the nat's ast-as-string as its input
-fn ast_parser<'cx>(
-    ecx: &'cx base::ExtCtxt,
-    num: u64,
-   mode: Mode,
-) -> parse::parser::Parser<'cx> {
-    let filemap = ecx
-        .codemap()
-        .new_filemap(String::from_str("<nat!>"), ast_as_str(ecx, num, mode));
-    let reader  = lexer::StringReader::new(
-        &ecx.parse_sess().span_diagnostic,
-        filemap);
-    parser::Parser::new(
-        ecx.parse_sess(),
-        ecx.cfg(),
-        Box::new(reader))
-}
-
-// Try to parse an integer literal and return a new parser which uses
-// the nat's ast-as-string as its input
-pub fn lit_parser<'cx>(
-     ecx: &'cx base::ExtCtxt,
-    args: &[ast::TokenTree],
-    mode: Mode,
-) -> Option<parse::parser::Parser<'cx>> {
-    let mut lit_parser = ecx.new_parser_from_tts(args);
-    if let ast::Lit_::LitInt(lit, _) = lit_parser.parse_lit().node {
-        Some(ast_parser(ecx, lit, mode))
-    } else {
-        None
-    }
-}
-
-// Expand Nat!(n) to a type-level binary nat where n is an int literal, e.g.,
-//     Nat!(1024)
-//         ==> (((((((((_1, _0), _0), _0), _0), _0), _0), _0), _0), _0)
-pub fn expand_ty<'cx>(
-     ecx: &'cx mut base::ExtCtxt,
-    span: codemap::Span,
-    args: &[ast::TokenTree],
-) -> Box<base::MacResult + 'cx> {
-    {
-        lit_parser(ecx, args, Mode::Ty)
-    }.and_then(|mut ast_parser| {
-        Some(base::MacEager::ty(ast_parser.parse_ty()))
-    }).unwrap_or_else(|| {
-        ecx.span_err(span, "Nat!: expected an integer literal argument");
-        base::DummyResult::any(span)
-    })
-}
-
-// Expand nat!(n) to a term-level binary nat where n is an int literal, e.g.,
-//     nat!(1024)
-//         ==> (((((((((_1, _0), _0), _0), _0), _0), _0), _0), _0), _0)
-pub fn expand_tm<'cx>(
-     ecx: &'cx mut base::ExtCtxt,
-    span: codemap::Span,
-    args: &[ast::TokenTree],
-) -> Box<base::MacResult + 'cx> {
-    {
-        lit_parser(ecx, args, Mode::Tm)
-    }.and_then(|mut ast_parser| {
-        Some(base::MacEager::expr(ast_parser.parse_expr()))
-    }).unwrap_or_else(|| {
-        ecx.span_err(span, "nat!: expected an integer literal argument");
-        base::DummyResult::any(span)
-    })
-}
-
-#[test]
-fn nats() {
-    let _: Nat!(42) = nat!(42);
-}
-```
-
-##### Optimization of `Expr`!
-
-Defining `Expr!` as a plugin would provide an opportunity to perform
-various optimizations of more complex type-level expressions during
-expansion. Partial evaluation would be one way to achieve
-this. Furthermore, expansion-time optimizations wouldn't be limited to
-arithmetic expressions but could be used for other data like HLists.
-
-##### Builtin alternatives: types parameterized by constant values
-
-The example with type-level naturals serves to illustrate some of the
-patterns type macros enable. This RFC is not intended to address the
-lack of constant value type parameterization and type-level numerics
-specifically. There is
-[another RFC here](https://github.com/rust-lang/rfcs/pull/884) which
-proposes extending the type system to address those issue.
-
 # Drawbacks
 
 There seem to be few drawbacks to implementing this feature as an