[WIP] Support Variables in Syntax

.cargo/config.toml

@@ -0,0 +1 @@
+rustflags = ["-Cinstrument-coverage"]

Cargo.toml

@@ -22,6 +22,7 @@ hex = "0.4"
 hex-literal = "0.3"
 indexmap = "1.5"
 k256 = { version = "0.10.2", features = ["std", "ecdsa", "serde"] }
+nom = "7.1.1"
 quickcheck = "1.0.3"
 quickcheck_macros = "1.0.0"
 reqwest = { version = "0.11.10", features = ["json"] }

src/an_elem.rs

@@ -210,7 +210,7 @@ impl AnElem for Value {
 
 
 /// AnElem::from_elem errors
-#[derive(Clone, Debug, Error)]
+#[derive(Clone, Debug, Error, PartialEq)]
 pub enum AnElemError {
     /// AnElem::from_elem: element popped from the Stack wasn't the expected type
     #[error("AnElem::from_elem: element popped from the stack\n\n{found}\n\nwasn't the expected type:\n{expected:?}")]

src/an_elem_return.rs

@@ -10,6 +10,12 @@ pub struct Return<T: AnElem> {
     return_value: Arc<Mutex<Option<T>>>,
 }
 
+impl<T: AnElem> Default for Return<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<T: AnElem> Return<T> {
     /// New Return slot with nothing in it
     pub fn new() -> Self {

src/arbitrary.rs

@@ -26,7 +26,8 @@ impl Arbitrary for ArbitraryNumber {
         } else {
             let x: f64 = Arbitrary::arbitrary(g);
             ArbitraryNumber { number:
-                Number::from_f64(x).unwrap_or(From::from(0u8))
+                Number::from_f64(x)
+                    .unwrap_or_else(|| From::from(0u8))
             }
         }
     }
@@ -51,7 +52,8 @@ impl Arbitrary for ArbitraryNumber {
             Some(self_f64) => Box::new(
                 self_f64.shrink()
                 .map(|x| ArbitraryNumber {
-                    number: Number::from_f64(x).unwrap_or(From::from(0u8)),
+                    number: Number::from_f64(x)
+                        .unwrap_or_else(|| From::from(0u8)),
                 })),
         }
     }

src/cli.rs

@@ -187,15 +187,15 @@ impl Cli {
     }
 
     /// Run Cli::parse_and_run_result and print its result
-    pub async fn parse_and_run(&self) -> () {
+    pub async fn parse_and_run(&self) {
         match self.parse_and_run_result().await {
             Ok(()) => println!("successful!"),
             Err(e) => println!("failed:\n{}\n", e),
         }
     }
 
     /// Run a set of Cli arguments
-    pub async fn run(&self) -> () {
+    pub async fn run(&self) {
         match self.command {
             None => self.parse_and_run().await,
             Some(Commands::Parse) => {

src/elem.rs

@@ -112,11 +112,11 @@ pub enum ElemSymbol {
 impl Arbitrary for ElemSymbol {
     fn arbitrary(g: &mut Gen) -> Self {
         let choices: Vec<ElemSymbol> = EnumSet::all().iter().collect();
-        *g.choose(&choices).unwrap_or_else(|| &Self::Unit)
+        *g.choose(&choices).unwrap_or(&Self::Unit)
     }
 
     fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
-        let self_copy = self.clone();
+        let self_copy = *self;
         Box::new(EnumSet::all().iter().filter(move |&x| x < self_copy))
     }
 }

src/elem_type.rs

@@ -51,10 +51,10 @@ impl Display for ElemType {
                .fold(String::new(),
                      |memo, x| {
                          let x_str: &'static str = From::from(x);
-                         if memo == "" {
+                         if memo.is_empty() {
                             x_str.to_string()
                          } else {
-                            memo + ", " + &x_str.to_string()
+                            memo + ", " + x_str
                          }
                     }
                ))
@@ -101,7 +101,7 @@ impl ElemSymbol {
             info: locations.iter()
                 .map(|&location|
                      ElemTypeInfo {
-                         location: location,
+                         location,
                     }).collect(),
         }
     }
@@ -119,11 +119,11 @@ impl ElemType {
     pub fn from_locations(type_set: EnumSet<ElemSymbol>,
                           locations: Vec<Location>) -> Self {
         ElemType {
-            type_set: type_set,
+            type_set,
             info: locations.iter()
                 .map(|&location|
                      ElemTypeInfo {
-                         location: location,
+                         location,
                     }).collect(),
         }
     }
@@ -136,10 +136,10 @@ impl ElemType {
     }
 
     /// Calculate the union of two ElemType's and append their metadata
-    pub fn union(&self, other: Self) -> Self {
+    pub fn union(&self, other: &mut Self) -> Self {
         let both = self.type_set.union(other.type_set);
         let mut both_info = self.info.clone();
-        both_info.append(&mut other.info.clone());
+        both_info.append(&mut other.info);
         ElemType {
             type_set: both,
             info: both_info,
@@ -149,7 +149,7 @@ impl ElemType {
     /// Unify two ElemType's by returning their intersection and combining their metadata
     ///
     /// Fails if their intersection is empty (i.e. if it results in an empty type)
-    pub fn unify(&self, other: Self) -> Result<Self, ElemTypeError> {
+    pub fn unify(&self, other: &mut Self) -> Result<Self, ElemTypeError> {
         let both = self.type_set.intersection(other.type_set);
         if both.is_empty() {
             Err(ElemTypeError::UnifyEmpty {
@@ -158,7 +158,7 @@ impl ElemType {
             })
         } else {
             let mut both_info = self.info.clone();
-            both_info.append(&mut other.info.clone());
+            both_info.append(&mut other.info);
             Ok(ElemType {
                 type_set: both,
                 info: both_info,
@@ -239,13 +239,18 @@ impl StackType {
         self.types.len()
     }
 
+    /// Is length of the StackType empty?
+    pub fn is_empty(&self) -> bool {
+        self.types.is_empty()
+    }
+
     /// Push the given ElemType to the StackType
-    pub fn push(&mut self, elem_type: ElemType) -> () {
+    pub fn push(&mut self, elem_type: ElemType) {
         self.types.insert(0, elem_type)
     }
 
     /// Push (count) copies of the given ElemType to the StackType
-    pub fn push_n(&mut self, elem_type: ElemType, count: usize) -> () {
+    pub fn push_n(&mut self, elem_type: ElemType, count: usize) {
         for _index in 0..count {
             self.push(elem_type.clone())
         }

src/elems.rs

@@ -18,7 +18,7 @@ use thiserror::Error;
 // - random typed program?
 
 /// Errors thrown by Elems::pop
-#[derive(Clone, Debug, Error)]
+#[derive(Clone, Debug, Error, PartialEq)]
 pub enum ElemsPopError {
     /// "Elems::pop singleton: tried to pop an Elem that was not found:\nelem_symbol:\n{elem_symbol:?}\n\n{error}"
     #[error("Elems::pop singleton: tried to pop an Elem that was not found:\nelem_symbol:\n{elem_symbol:?}\n\n{error}")]

src/elems_input_output_or.rs

@@ -79,7 +79,7 @@ where
             .map(|x| {
                 match x {
                     Or::Left(array) => Self::Left {
-                        array: array,
+                        array,
                         returning: Return::new(),
                     },
                     Or::Right(y) => Self::Right(y),
@@ -125,13 +125,13 @@ where
         let mut type_tl = IOElems::type_of(PhantomData::<U>)
             .map_err(|e| ElemsPopError::ReturnOrTl(Arc::new(e)))?;
         let last_type_id = type_tl.context.max_type_id()
-            .map_err(|e| ElemsPopError::ReturnOrContextError(e))?;
+            .map_err(ElemsPopError::ReturnOrContextError)?;
         let next_type_id = type_tl.context.push(ElemType {
             type_set: AnElem::elem_symbol(PhantomData::<T>),
             info: vec![],
         });
         type_tl.context.unify(last_type_id, next_type_id)
-            .map_err(|e| ElemsPopError::ReturnOrContextError(e))?;
+            .map_err(ElemsPopError::ReturnOrContextError)?;
         Ok(type_tl)
     }
 }

src/elems_input_output_singleton.rs

@@ -98,7 +98,7 @@ where
             info: vec![],
         });
         Ok(Type {
-            context: context,
+            context,
             i_type: (1..num_inputs).into_iter().map(|_| type_id).collect(),
             o_type: vec![type_id],
         })

src/elems_or.rs

@@ -80,7 +80,7 @@ where
         match self {
             Self::Left(array) => IterOr::Left(
                 Singleton {
-                    array: array,
+                    array,
                 }.into_iter()
             ),
             Self::Right(xs) => IterOr::Right(xs.into_iter()),
@@ -98,8 +98,6 @@ where
     type N = N;
     type Tl = U;
 
-    // fn left(_s: PhantomData<Self>, x: GenericArray<Self::Hd, Self::N>) -> Self { Self::Left(x) }
-    // fn right(_s: PhantomData<Self>, x: Self::Tl) -> Self { Self::Right(x) }
     fn or<V, F: Fn(&GenericArray<Self::Hd, Self::N>) -> V, G: Fn(&Self::Tl) -> V>(&self, f: F, g: G) -> V {
         match self {
             Self::Left(x) => f(x),
@@ -132,8 +130,8 @@ where
             type_set: AnElem::elem_symbol(PhantomData::<T>),
             info: vec![],
         };
-        let elem_type_tl = Elems::elem_type(PhantomData::<U>)?;
-        Ok(elem_type_hd.union(elem_type_tl))
+        let mut elem_type_tl = Elems::elem_type(PhantomData::<U>)?;
+        Ok(elem_type_hd.union(&mut elem_type_tl))
     }
 }
 

src/elems_singleton.rs

@@ -70,7 +70,7 @@ where
             }
         })?;
         Ok(Singleton {
-            array: array,
+            array,
         })
     }
 

src/json_template.rs

@@ -9,12 +9,19 @@ use indexmap::IndexMap;
 use serde_json::{Map, Number, Value};
 use thiserror::Error;
 
+// TODO: relocate
 /// Map<String, T> defined to be convenient to Serialize and Deserialize
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct TMap<T> {
     map: IndexMap<String, T>,
 }
 
+impl<T> Default for TMap<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<T> TMap<T> {
     /// IndexMap::new
     pub fn new() -> Self {
@@ -78,7 +85,7 @@ where
         }
 
         Ok(TMap {
-            map: map,
+            map,
         })
     }
 }
@@ -138,7 +145,7 @@ impl TValue {
             Value::Bool(x) => Self::Bool(x),
             Value::Number(x) => Self::Number(x),
             Value::String(x) => Self::String(x),
-            Value::Array(x) => Self::Array(x.into_iter().map(|x| TValue::from_json(x)).collect()),
+            Value::Array(x) => Self::Array(x.into_iter().map(TValue::from_json).collect()),
             Value::Object(x) => Self::Object(TMap {
                 map: x.into_iter().map(|(x, y)| (x, TValue::from_json(y))).collect()
             }),
@@ -164,13 +171,13 @@ impl TValue {
             Self::String(x) => Ok(Value::String(x)),
             Self::Array(x) => Ok(Value::Array(x.into_iter().map(|y| y.run(variables.clone())).collect::<Result<Vec<Value>, TValueRunError>>()?)),
             Self::Object(x) => Ok(Value::Object(x.map.into_iter().map(|(y, z)| Ok((y, z.run(variables.clone())?))).collect::<Result<Map<String, Value>, TValueRunError>>()?)),
-            Self::Var(x) => {
-                variables.get(&x)
-                    .map(|y| y.clone())
+            Self::Var(variable) => {
+                variables.get(&variable)
+                    .cloned()
                     .ok_or_else(|| TValueRunError {
-                    variable: x,
+                    variable,
                     value: vec![self_copy],
-                    variables: variables,
+                    variables,
                 })
             },
         }
@@ -198,12 +205,12 @@ impl Template {
     pub fn new(template: TValue) -> Self {
         Self {
             variables: Map::new(),
-            template: template,
+            template,
         }
     }
 
     /// Set the given variable name to the given Value
-    pub fn set(&mut self, name: String, value: Value) -> () {
+    pub fn set(&mut self, name: String, value: Value) {
         self.variables.insert(name, value);
     }
 

src/lib.rs

@@ -2,8 +2,9 @@
 //! Cryptoscript Rust Library
 //! See cli for the command line interface
 
-#![warn(missing_docs, elided_lifetimes_in_paths, explicit_outlives_requirements, keyword_idents, missing_copy_implementations, missing_debug_implementations, non_ascii_idents, noop_method_call, single_use_lifetimes, trivial_casts, trivial_numeric_casts, unreachable_pub, unused_extern_crates, unused_import_braces, unused_lifetimes, unused_qualifications)]
+#![warn(missing_docs, elided_lifetimes_in_paths, explicit_outlives_requirements, keyword_idents, missing_copy_implementations, missing_debug_implementations, non_ascii_idents, noop_method_call, trivial_casts, trivial_numeric_casts, unreachable_pub, unused_extern_crates, unused_import_braces, unused_lifetimes, unused_qualifications)]
 
+// single_use_lifetimes, 
 // #![warn(unused_crate_dependencies)]
 // #![warn(unused_results)]
 
@@ -80,6 +81,11 @@ pub use typed_instrs::Instrs;
 mod parse;
 pub use parse::{parse, parse_json};
 
+mod parse_utils;
+pub use parse_utils::{parse_string, whitespace_delimited};
+mod parse_nom;
+pub use parse_nom::{parse_nom, SourceCode, SourceBlock, Comment, Var, Assignment, App, Expr, TypeAnnotation, InstructionsWriter};
+
 mod rest_api;
 pub use rest_api::Api;
 mod cli;
@@ -142,7 +148,7 @@ fn sha256(input: &Vec<u8>) -> Vec<u8> {
 
     // read hash digest and consume hasher
     let result = hasher.finalize();
-    return result.to_vec();
+    result.to_vec()
 }
 
 #[cfg(test)]

src/location.rs

@@ -10,7 +10,7 @@ pub struct LineNo {
 impl From<usize> for LineNo {
     fn from(line_no: usize) -> Self {
         LineNo {
-            line_no: line_no,
+            line_no,
         }
     }
 }
@@ -35,7 +35,7 @@ impl LineNo {
     pub fn in_at(&self, argument_index: usize) -> Location {
         Location {
             line_no: *self,
-            argument_index: argument_index,
+            argument_index,
             is_input: true,
         }
     }
@@ -47,7 +47,7 @@ impl LineNo {
     pub fn out_at(&self, argument_index: usize) -> Location {
         Location {
             line_no: *self,
-            argument_index: argument_index,
+            argument_index,
             is_input: false,
         }
     }

src/main.rs

@@ -328,8 +328,8 @@ async fn main() {
 
 
 
-    println!("");
-    println!("");
+    println!();
+    println!();
     // println!("Template test:");
 
     // ERC-20 token balance (currently)