Allow quoting

src/env.rs

@@ -17,7 +17,7 @@ pub struct Rule {
     pub result: RuleResult,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct Operation {
     pub commutative: bool,
     pub associative: bool,

src/lib.rs

@@ -230,6 +230,11 @@ fn flatten_tree(v: &mut Value, env: &Env) -> Result<()> {
                     }
                 }
             }
+            /*
+            for child in args.iter_mut() {
+                flatten_tree(child, env)?;
+            }
+            */
             // Also do sorting after flattening, to avoid any weirdness with ordering.
             canonical_sort(v, env)?;
             return Ok(())
@@ -420,7 +425,6 @@ x^n/x = x^(n-1)
 PushRuleset[factor_postpostprocess]
 ";
 
-
 pub struct ImperativeCtx {
     bindings: Bindings,
     current_ruleset_stage: InlinableString,

src/parse.rs

@@ -10,7 +10,15 @@ pub enum Token { Number(InlinableString), OpenBracket, CloseBracket, Op(char), E
 enum LexState {
     Number(InlinableString),
     Identifier(InlinableString),
-    None
+    None,
+    Quote
+}
+
+pub fn is_special_character(c: char) -> bool {
+    match c {
+        '#' | '+' | '(' | ')' | '-' | '/' | '*' | '^' | '=' | '[' | ']' | ',' => true,
+        _ => false
+    }
 }
 
 // lexer
@@ -30,20 +38,29 @@ pub fn lex(input: &str) -> Result<Vec<Token>> {
                 n.push(char);
                 LexState::Number(n)
             },
+            // Allow quoting special characters
+            ('`', LexState::None) => {
+                LexState::Quote
+            },
             // if special character seen, commit existing state and push operator/bracket/comma token
-            ('#' | '+' | '(' | ')' | '-' | '/' | '*' | '^' | '=' | '[' | ']' | ',', state) => {
+            (c, state) if is_special_character(c) => {
-                match state {
+                if let LexState::Quote = state {
-                    LexState::Number(s) => toks.push(Token::Number(s)),
+                    toks.push(Token::Identifier(char_to_string(char)));
-                    LexState::Identifier(s) => toks.push(Token::Identifier(s)),
+                    LexState::None
-                    _ => ()
+                } else {
-                };
+                    match state {
-                toks.push(match char {
+                        LexState::Number(s) => toks.push(Token::Number(s)),
-                    '(' => Token::OpenBracket, ')' => Token::CloseBracket,
+                        LexState::Identifier(s) => toks.push(Token::Identifier(s)),
-                    '[' => Token::OpenSqBracket, ']' => Token::CloseSqBracket,
+                        _ => ()
-                    ',' => Token::Comma,
+                    };
-                    a => Token::Op(a)
+                    toks.push(match char {
-                });
+                        '(' => Token::OpenBracket, ')' => Token::CloseBracket,
-                LexState::None  
+                        '[' => Token::OpenSqBracket, ']' => Token::CloseSqBracket,
+                        ',' => Token::Comma,
+                        a => Token::Op(a)
+                    });
+                    LexState::None  
+                }
             },
             // semicolon or newline is break
             (';' | '\n', state) => {

src/value.rs

@@ -5,7 +5,7 @@ use std::fmt::{self, Write};
 use itertools::Itertools;
 use anyhow::{Result, anyhow};
 
-use crate::parse::{Ast, precedence};
+use crate::parse::{Ast, precedence, is_special_character};
 use crate::env::{Env, Bindings};
 use crate::util::char_to_string;
 use crate::interval_arithmetic::Interval;
@@ -179,7 +179,16 @@ impl Value {
                 Value::ExactNum(x) => if *x >= 0 {
                     write!(f, "{}", x)
                 } else { write!(f, "Negate[{}]", -x) },
-                Value::Identifier(i) => write!(f, "{}", i),
+                Value::Identifier(i) => {
+                    for c in i.chars() {
+                        if is_special_character(c) {
+                            write!(f, "`{}", c)?;
+                        } else {
+                            write!(f, "{}", c)?;
+                        }
+                    }
+                    Ok(())
+                },
                 Value::Call(head, args) => {
                     match env.ops.get(head) {
                         Some(_) => {