good progress towards implementing custom derive

Author: coder543

Cargo.toml

@@ -5,7 +5,8 @@ authors = ["Josh Leverette <coder543@gmail.com>"]
 
 # uncomment if doing benchmarks
 # otherwise, it just slows down compilation of examples
-# [dev-dependencies]
+[dev-dependencies]
+zap_derive = { path = "./zap-derive" }
 # criterion = "0.2.3"
 # handlebars = "0.32.0"
 # serde_json = "1.0.16"

benches/benchmark.rs

@@ -126,9 +126,11 @@ impl Runner<PersonNums, PersonStrs, PersonFilters> for Person {
 
     fn filter_str(&self, filter: PersonFilters, _args: &[f64], input: &str, buffer: &mut String) {
         match filter {
-            PersonFilters::ToUpper => for c in input.as_bytes() {
-                buffer.push(c.to_ascii_uppercase() as char)
-            },
+            PersonFilters::ToUpper => {
+                for c in input.as_bytes() {
+                    buffer.push(c.to_ascii_uppercase() as char)
+                }
+            }
             _ => unreachable!(),
         }
     }

examples/derive_example.rs

@@ -0,0 +1,86 @@
+extern crate zap;
+
+#[macro_use]
+extern crate zap_derive;
+
+use zap::{compile, Environment, FilterInput, Runner};
+
+use std::io::stdout;
+
+#[derive(Clone, ZapRunner)]
+struct Person {
+    id: u64,
+    name: String,
+    age: u32,
+    weight: f64,
+}
+
+#[derive(ZapEnv)]
+#[runner = "Person"]
+#[filter = "sqrt/0i"]
+#[filter = "round/1i"]
+#[filter = "toupper/0s"]
+struct Provider {
+    provider: String,
+    provider_code: u32,
+}
+
+fn sqrt(_data: &Person, args: &[f64], input: f64) -> f64 {
+    input.sqrt()
+}
+
+fn round(_data: &Person, args: &[f64], input: f64) -> f64 {
+    let digits = args[0];
+    let factor = 10u32.pow(digits as u32) as f64;
+    let value = (input * factor).round() as f64;
+    value / factor
+}
+
+fn to_upper(_data: &Person, _args: &[f64], input: &str, buffer: &mut String) {
+    for c in input.as_bytes() {
+        buffer.push(c.to_ascii_uppercase() as char)
+    }
+}
+
+fn main() {
+    let template =
+        "{{provider}} {{provider_code + 4}} {{id}} {{name | toupper}} {{age | sqrt}} {{weight / 2.2 | round 2}}kg\n";
+
+    let env = Provider {
+        provider: "apns".to_string(),
+        provider_code: 31,
+    };
+
+    let bytecode = match compile(template, &env) {
+        Ok(bc) => bc,
+        Err(err) => {
+            eprintln!("error compiling template: {}", err);
+            return;
+        }
+    };
+
+    // println!("bytecode: {:#?}", bytecode);
+
+    // build up a group of 100 (similar) people
+    let mut group = vec![];
+    for i in 0..100 {
+        group.push(Person {
+            id: 12 + i,
+            name: "Bob".to_string(),
+            age: 49,
+            weight: 170.3 + i as f64,
+        });
+    }
+
+    // reuse these allocations throughout the output process
+    let mut buffer = String::with_capacity(8);
+    let mut stack = Vec::with_capacity(8);
+    let stdout = stdout();
+    let mut stdout_lock = stdout.lock();
+
+    for person in group {
+        bytecode
+            .run_with(&person, &mut buffer, &mut stack, &mut stdout_lock)
+            .unwrap();
+    }
+}

examples/example.rs

@@ -2,6 +2,7 @@ extern crate zap;
 
 use zap::{compile, Environment, FilterInput, Runner};
 
+use std::borrow::Cow;
 use std::io::stdout;
 
 #[derive(Clone)]
@@ -86,9 +87,9 @@ impl Runner<PersonNums, PersonStrs, PersonFilters> for Person {
         }
     }
 
-    fn str_var(&self, var: PersonStrs) -> &str {
+    fn str_var(&self, var: PersonStrs) -> Cow<str> {
         match var {
-            PersonStrs::Name => &self.name,
+            PersonStrs::Name => self.name.as_str().into(),
         }
     }
 
@@ -116,19 +117,26 @@ impl Runner<PersonNums, PersonStrs, PersonFilters> for Person {
         unreachable!()
     }
 
-    fn filter_str(&self, filter: PersonFilters, _args: &[f64], input: &str, buffer: &mut String) {
+    fn filter_str(
+        &self,
+        filter: PersonFilters,
+        _args: &[f64],
+        input: Cow<str>,
+        buffer: &mut String,
+    ) {
         match filter {
-            PersonFilters::ToUpper => for c in input.as_bytes() {
-                buffer.push(c.to_ascii_uppercase() as char)
-            },
+            PersonFilters::ToUpper => {
+                for c in input.as_bytes() {
+                    buffer.push(c.to_ascii_uppercase() as char)
+                }
+            }
             _ => unreachable!(),
         }
     }
 }
 
 fn main() {
-    let template =
-        "{{provider}} {{provider_code + 4}} {{id}} {{name | toupper}} {{age | sqrt}} {{weight / 2.2 | round 2}}kg\n";
+    let template = "{{provider}} {{provider_code + 4}} {{id}} {{name | toupper}} {{age | sqrt}} {{weight / 2.2 | round 2}}kg\n";
 
     let env = Provider {
         provider: "apns".to_string(),

src/bytecode.rs

@@ -2,6 +2,7 @@
 
 use super::{Environment, FilterInput, Runner};
 use ast::*;
+use std::borrow::Cow;
 use std::fmt::Debug;
 use std::io::Write;
 use tokenizer::Operator;
@@ -120,7 +121,7 @@ impl<
                     //CallRegStr could probably do without this string allocation
                     let string = pop!(stack).to_string();
                     buffer.clear();
-                    runner.filter_str(id, args, &string, buffer);
+                    runner.filter_str(id, args, Cow::from(string), buffer);
                     write!(output, "{}", buffer)?
                 }
             }

src/lib.rs

@@ -3,6 +3,7 @@ pub mod bytecode;
 pub mod optimizer;
 pub mod tokenizer;
 
+use std::borrow::Cow;
 use std::fmt::Debug;
 
 pub use bytecode::Bytecode;
@@ -13,8 +14,7 @@ pub enum FilterInput<StrEnum> {
     Stringified,
 }
 
-pub trait Environment<'a, NumEnum: 'a, StrEnum: 'a + Debug + PartialEq, FilterEnum: 'a>
-     {
+pub trait Environment<'a, NumEnum: 'a, StrEnum: 'a + Debug + PartialEq, FilterEnum: 'a> {
     fn num_constant(&self, &str) -> Option<f64>;
     fn str_constant(&'a self, &str) -> Option<&'a str>;
 
@@ -28,13 +28,13 @@ pub trait Environment<'a, NumEnum: 'a, StrEnum: 'a + Debug + PartialEq, FilterEn
 #[allow(unused)]
 pub trait Runner<NumEnum, StrEnum, FilterEnum> {
     fn num_var(&self, NumEnum) -> f64;
-    fn str_var(&self, StrEnum) -> &str;
+    fn str_var(&self, StrEnum) -> Cow<str>;
 
     fn filter_num(&self, FilterEnum, &[f64], f64) -> f64;
 
     // the fourth argument is a reusable buffer to reduce allocation
     fn filter_id(&self, FilterEnum, &[f64], StrEnum, &mut String);
-    fn filter_str(&self, FilterEnum, &[f64], &str, &mut String);
+    fn filter_str(&self, FilterEnum, &[f64], Cow<str>, &mut String);
 }
 
 pub fn compile<

zap-derive/.gitignore

@@ -0,0 +1,4 @@
+
+/target
+**/*.rs.bk
+Cargo.lock

zap-derive/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+authors = ["Josh Leverette <coder543@gmail.com>"]
+name = "zap_derive"
+version = "0.1.0"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+quote = "0.5.2"
+syn = { version = "0.13.10", features = ["extra-traits"] }