Draft: Add variable definitions via let

core/src/ast/query.rs

@@ -21,6 +21,7 @@ pub enum Query {
     UnitsFor(Expr),
     Search(String),
     Error(String),
+    Let(String, Expr),
 }
 
 impl fmt::Display for Conversion {

core/src/context.rs

@@ -32,6 +32,7 @@ pub struct Context {
     pub short_output: bool,
     pub use_humanize: bool,
     pub previous_result: Option<Number>,
+    pub variables: BTreeMap<String, Number>,
 }
 
 impl Default for Context {
@@ -65,6 +66,7 @@ impl Context {
             substance_symbols: BTreeMap::new(),
             temporaries: BTreeMap::new(),
             previous_result: None,
+            variables: BTreeMap::new(),
         }
     }
 
@@ -104,6 +106,9 @@ impl Context {
                     });
                 }
             }
+            if let Some(v) = ctx.variables.get(name).cloned() {
+                return Some(v);
+            }
             None
         }
 

core/src/eval.rs

@@ -701,7 +701,7 @@ impl Context {
     }
 
     /// Evaluates an expression, include `->` conversions.
-    pub fn eval_outer(&self, expr: &Query) -> Result<QueryReply, QueryError> {
+    pub fn eval_outer(&mut self, expr: &Query) -> Result<QueryReply, QueryError> {
         match *expr {
             Query::Expr(Expr::Unit { ref name })
                 if {
@@ -1178,7 +1178,18 @@ impl Context {
                         s.to_reply(self).map_err(QueryError::generic)?,
                     )),
                 }
-            }
+            },
+            Query::Let(ref var_name, ref expr) => {
+                // todo: check whether already defined with self.lookup(var_name)
+                let res = self.eval(expr)?;
+                if let Value::Number(num) = res {
+                    let parts = num.to_parts(self);
+                    self.variables.insert(var_name.clone(), num);
+                    Ok(QueryReply::Number(parts))
+                } else {
+                    Err(QueryError::generic("let expressions currently only supported for numeric results".to_string()))
+                }
+            },
             Query::Error(ref e) => Err(QueryError::generic(e.clone())),
         }
     }

core/src/text_query.rs

@@ -753,6 +753,17 @@ pub fn parse_query(iter: &mut Iter<'_>) -> Query {
                 return Query::Search(s.clone());
             }
         }
+        Some(Token::Ident(ref s)) if s == "let" => {
+            iter.next();
+            if let Some(Token::Ident(ref s)) = iter.peek().cloned() {
+               iter.next();
+               if let Some(Token::Equals) = iter.peek() {
+                   iter.next();
+                   return Query::Let(s.clone(), parse_eq(iter));
+               }
+            }
+            return Query::Error("let needs to have form `let var = expr`".to_string());
+        }
         _ => (),
     }
     let left = parse_eq(iter);