Unify u32-based identifiers into common code

Create a new type Id<T> paramaterized by whatever specific class of IDs
is relevant to a domain; create stores and macros to support this; and
repace the existing Id types.

rustfmt.toml

@@ -0,0 +1,8 @@
+
+max_width = 110
+use_small_heuristics = "max"
+imports_indent = "block"
+imports_granularity = "crate"
+group_imports = "stdexternalcrate"
+match_arm_blocks = false
+where_single_line = true

schala-lang/language/src/ast/mod.rs

@@ -2,7 +2,6 @@
 #![allow(clippy::enum_variant_names)]
 
 use std::rc::Rc;
-use std::fmt;
 use std::convert::{AsRef, From};
 
 mod visitor;
@@ -13,41 +12,19 @@ pub use visitor::*;
 
 use crate::derivative::Derivative;
 use crate::tokenizing::Location;
+use crate::identifier::{Id, define_id_kind};
 
-/// An abstract identifier for an AST node. Note that
+define_id_kind!(ASTItem);
-/// the u32 index limits the size of an AST to 2^32 nodes.
-#[derive(Debug, PartialEq, Eq, Hash, Clone, Default)]
-pub struct ItemId {
-  pub idx: u32,
-}
 
-impl ItemId {
+/*
-  fn new(n: u32) -> ItemId {
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Default)]
-    ItemId { idx: n }
+pub struct ASTItem;
-  }
+impl IdKind for ASTItem {
+    fn tag() -> &'static str { "ASTItem" }
 }
+*/
 
-impl fmt::Display for ItemId {
+pub type ItemId = Id<ASTItem>;
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    write!(f, "ItemId:{}", self.idx)
-  }
-}
-
-pub struct ItemIdStore {
-  last_idx: u32
-}
-
-impl ItemIdStore {
-  pub fn new() -> ItemIdStore {
-    ItemIdStore { last_idx: 0 }
-  }
-
-  pub fn fresh(&mut self) -> ItemId {
-    let idx = self.last_idx;
-    self.last_idx += 1;
-    ItemId::new(idx)
-  }
-}
 
 #[derive(Derivative, Debug)]
 #[derivative(PartialEq)]

schala-lang/language/src/identifier.rs

@@ -0,0 +1,74 @@
+use std::{
+    fmt::{self, Debug},
+    hash::Hash,
+    marker::PhantomData,
+};
+
+pub trait IdKind: Debug + Copy + Clone + Hash + PartialEq + Eq + Default {
+    fn tag() -> &'static str;
+}
+
+/// A generalized abstract identifier type of up to 2^32-1 entries.
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, Default)]
+pub struct Id<T>
+where T: IdKind
+{
+    idx: u32,
+    t: PhantomData<T>,
+}
+
+impl<T> Id<T>
+where T: IdKind
+{
+    fn new(n: u32) -> Self {
+        Self { idx: n, t: PhantomData }
+    }
+
+    #[allow(dead_code)]
+    pub fn as_u32(&self) -> u32 {
+        self.idx
+    }
+}
+
+impl<T> fmt::Display for Id<T>
+where T: IdKind
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}:{}", self.idx, T::tag())
+    }
+}
+
+pub struct IdStore<T>
+where T: IdKind
+{
+    last_idx: u32,
+    t: PhantomData<T>,
+}
+
+impl<T> IdStore<T>
+where T: IdKind
+{
+    pub fn new() -> Self {
+        Self { last_idx: 0, t: PhantomData }
+    }
+
+    pub fn fresh(&mut self) -> Id<T> {
+        let idx = self.last_idx;
+        self.last_idx += 1;
+        Id::new(idx)
+    }
+}
+
+macro_rules! define_id_kind {
+    ($name:ident) => {
+        #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, Default)]
+        pub struct $name;
+        impl crate::identifier::IdKind for $name {
+            fn tag() -> &'static str {
+                stringify!($name)
+            }
+        }
+    };
+}
+
+pub(crate) use define_id_kind;

schala-lang/language/src/lib.rs

@@ -23,10 +23,10 @@ mod tokenizing;
 mod symbol_table;
 mod builtin;
 mod error;
-//mod eval;
-//mod reduced_ast;
 mod reduced_ir;
 mod tree_walk_eval;
+#[macro_use]
+mod identifier;
 
 mod schala;
 

schala-lang/language/src/parsing/mod.rs

@@ -170,6 +170,7 @@ use crate::tokenizing::TokenKind::*;
 use crate::tokenizing::Location;
 
 use crate::ast::*;
+use crate::identifier::IdStore;
 
 /// Represents a parsing error
 #[derive(Debug)]
@@ -201,7 +202,7 @@ pub struct Parser {
   parse_record: Vec<ParseRecord>,
   parse_level: u32,
   restrictions: ParserRestrictions,
-  id_store: ItemIdStore,
+  id_store: IdStore<ASTItem>,
 }
 
 
@@ -252,7 +253,7 @@ impl Parser {
       parse_record: vec![],
       parse_level: 0,
       restrictions: ParserRestrictions { no_struct_literal: false },
-      id_store: ItemIdStore::new(),
+      id_store: IdStore::new(),
     }
   }
 

schala-lang/language/src/symbol_table/mod.rs

@@ -14,42 +14,10 @@ mod resolver;
 mod symbol_trie;
 use symbol_trie::SymbolTrie;
 mod test;
+use crate::identifier::{Id, IdStore, define_id_kind};
 
-
+define_id_kind!(DefItem);
-//TODO parameterize different types of ID
+pub type DefId = Id<DefItem>;
-/// ID used for definitions
-#[derive(Debug, PartialEq, Eq, Hash, Clone, Default)]
-pub struct DefId {
-  idx: u32,
-}
-
-impl DefId {
-  pub fn as_u32(&self) -> u32 {
-      self.idx
-  }
-}
-
-impl fmt::Display for DefId {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    write!(f, "DefId:{}", self.idx)
-  }
-}
-
-pub struct DefIdStore {
-  last_idx: u32
-}
-
-impl DefIdStore {
-  pub fn new() -> Self {
-    Self { last_idx: 0 }
-  }
-
-  pub fn fresh(&mut self) -> DefId {
-    let idx = self.last_idx;
-    self.last_idx += 1;
-    DefId { idx }
-  }
-}
 
 /// Fully-qualified symbol name
 #[derive(Debug, Clone, Eq, PartialEq, Hash, PartialOrd, Ord)]
@@ -170,7 +138,7 @@ impl<K> NameTable<K> {
 //cf. p. 150 or so of Language Implementation Patterns
 pub struct SymbolTable {
 
-    def_id_store: DefIdStore,
+    def_id_store: IdStore<DefItem>,
 
     /// Used for import resolution.
     symbol_trie: SymbolTrie,
@@ -190,7 +158,7 @@ pub struct SymbolTable {
 impl SymbolTable {
     pub fn new() -> SymbolTable {
         SymbolTable {
-            def_id_store: DefIdStore::new(),
+            def_id_store: IdStore::new(),
             symbol_trie: SymbolTrie::new(),
             fq_names: NameTable::new(),
             types: NameTable::new(),

schala-lang/language/src/tree_walk_eval/mod.rs

@@ -1,12 +1,14 @@
-use crate::reduced_ir::{ReducedIR, Expression, Lookup, Callable, FunctionDefinition, Statement, Literal, Alternative, Pattern};
+use std::{convert::From, fmt::Write, rc::Rc};
-use crate::symbol_table::{DefId};
-use crate::util::ScopeStack;
-use crate::builtin::Builtin;
-use crate::typechecking::TypeId;
 
-use std::fmt::Write;
+use crate::{
-use std::rc::Rc;
+    builtin::Builtin,
-use std::convert::From;
+    reduced_ir::{
+        Alternative, Callable, Expression, FunctionDefinition, Literal, Lookup, Pattern, ReducedIR, Statement,
+    },
+    symbol_table::DefId,
+    typechecking::TypeId,
+    util::ScopeStack,
+};
 
 mod test;
 
@@ -21,7 +23,7 @@ pub struct State<'a> {
 //evaluator
 #[derive(Debug, PartialEq, Eq, Hash, Clone)]
 enum Memory {
-    Index(u32)
+    Index(u32),
 }
 
 // This is for function param lookups, and is a hack
@@ -39,22 +41,18 @@ impl From<&DefId> for Memory {
 
 #[derive(Debug)]
 struct RuntimeError {
-    msg: String
+    msg: String,
 }
 
 impl From<String> for RuntimeError {
     fn from(msg: String) -> Self {
-        Self {
+        Self { msg }
-            msg
-        }
     }
 }
 
 impl From<&str> for RuntimeError {
     fn from(msg: &str) -> Self {
-        Self {
+        Self { msg: msg.to_string() }
-            msg: msg.to_string(),
-        }
     }
 }
 
@@ -92,7 +90,6 @@ impl From<Primitive> for MemoryValue {
     }
 }
 
-
 impl MemoryValue {
     fn to_repl(&self) -> String {
         match self {
@@ -126,26 +123,23 @@ enum Primitive {
     Tuple(Vec<Primitive>),
     Literal(Literal),
     Callable(Callable),
-    Object {
+    Object { type_id: TypeId, tag: u32, items: Vec<Primitive> },
-        type_id: TypeId,
-        tag: u32,
-        items: Vec<Primitive>
-    },
 }
 
 impl Primitive {
     fn to_repl(&self) -> String {
         match self {
             Primitive::Object { type_id, items, .. } if items.is_empty() => type_id.local_name().to_string(),
-            Primitive::Object { type_id, items, .. } =>
+            Primitive::Object { type_id, items, .. } => {
-                format!("{}{}", type_id.local_name(), paren_wrapped(items.iter().map(|item| item.to_repl()))),
+                format!("{}{}", type_id.local_name(), paren_wrapped(items.iter().map(|item| item.to_repl())))
+            }
             Primitive::Literal(lit) => match lit {
                 Literal::Nat(n) => format!("{}", n),
                 Literal::Int(i) => format!("{}", i),
                 Literal::Float(f) => format!("{}", f),
                 Literal::Bool(b) => format!("{}", b),
                 Literal::StringLit(s) => format!("\"{}\"", s),
-            }
+            },
             Primitive::Tuple(terms) => paren_wrapped(terms.iter().map(|x| x.to_repl())),
             Primitive::Callable(..) => "<some-callable>".to_string(),
         }
@@ -164,9 +158,7 @@ impl From<Literal> for Primitive {
 
 impl<'a> State<'a> {
     pub fn new() -> Self {
-        Self {
+        Self { environments: ScopeStack::new(Some("global".to_string())) }
-            environments: ScopeStack::new(Some("global".to_string()))
-        }
     }
 
     pub fn evaluate(&mut self, reduced: ReducedIR, repl: bool) -> Vec<Result<String, String>> {
@@ -179,9 +171,7 @@ impl<'a> State<'a> {
 
         for statement in reduced.entrypoint.into_iter() {
             match self.statement(statement) {
-                Ok(Some(output)) if repl => {
+                Ok(Some(output)) if repl => acc.push(Ok(output.to_repl())),
-                    acc.push(Ok(output.to_repl()))
-                },
                 Ok(_) => (),
                 Err(error) => {
                     acc.push(Err(error.msg));
@@ -200,11 +190,7 @@ impl<'a> State<'a> {
                 ret = Some(prim);
             }
         }
-        Ok(if let Some(ret) = ret {
+        Ok(if let Some(ret) = ret { ret } else { self.expression(Expression::unit())? })
-            ret
-        } else {
-            self.expression(Expression::unit())?
-        })
     }
 
     fn statement(&mut self, stmt: Statement) -> EvalResult<Option<MemoryValue>> {
@@ -214,7 +200,7 @@ impl<'a> State<'a> {
                 let evaluated = self.expression(expr)?;
                 self.environments.insert(id.into(), evaluated.into());
                 Ok(None)
-            },
+            }
             Statement::Expression(expr) => {
                 let evaluated = self.expression(expr)?;
                 Ok(Some(evaluated.into()))
@@ -225,57 +211,74 @@ impl<'a> State<'a> {
     fn expression(&mut self, expression: Expression) -> EvalResult<Primitive> {
         Ok(match expression {
             Expression::Literal(lit) => Primitive::Literal(lit),
-          Expression::Tuple(items) => Primitive::Tuple(items.into_iter().map(|expr| self.expression(expr)).collect::<EvalResult<Vec<Primitive>>>()?),
+            Expression::Tuple(items) => Primitive::Tuple(
+                items
+                    .into_iter()
+                    .map(|expr| self.expression(expr))
+                    .collect::<EvalResult<Vec<Primitive>>>()?,
+            ),
             Expression::Lookup(kind) => match kind {
                 Lookup::Function(ref id) => {
                     let mem = id.into();
                     match self.environments.lookup(&mem) {
                         // This just checks that the function exists in "memory" by ID, we don't
                         // actually retrieve it until `apply_function()`
-                      Some(MemoryValue::Function(_)) => Primitive::Callable(Callable::UserDefined(id.clone())),
+                        Some(MemoryValue::Function(_)) => {
+                            Primitive::Callable(Callable::UserDefined(id.clone()))
+                        }
                         x => return Err(format!("Function not found for id: {} : {:?}", id, x).into()),
                     }
-              },
+                }
                 Lookup::Param(n) => {
                     let mem = n.into();
                     match self.environments.lookup(&mem) {
                         Some(MemoryValue::Primitive(prim)) => prim.clone(),
                         e => return Err(format!("Param lookup error, got {:?}", e).into()),
                     }
-              },
+                }
                 Lookup::LocalVar(ref id) | Lookup::GlobalVar(ref id) => {
                     let mem = id.into();
                     match self.environments.lookup(&mem) {
                         Some(MemoryValue::Primitive(expr)) => expr.clone(),
-                      _ => return Err(format!("Nothing found for local/gloval variable lookup {}", id).into()),
+                        _ => {
+                            return Err(
+                                format!("Nothing found for local/gloval variable lookup {}", id).into()
+                            )
+                        }
+                    }
                 }
-              },
             },
             Expression::Assign { ref lval, box rval } => {
                 let mem = lval.into();
                 let evaluated = self.expression(rval)?;
                 self.environments.insert(mem, MemoryValue::Primitive(evaluated));
                 Primitive::unit()
-          },
+            }
             Expression::Call { box f, args } => self.call_expression(f, args)?,
-          Expression::Callable(Callable::DataConstructor { type_id, arity, tag }) if arity == 0 => Primitive::Object {
+            Expression::Callable(Callable::DataConstructor { type_id, arity, tag }) if arity == 0 => {
-              type_id, tag, items: vec![]
+                Primitive::Object { type_id, tag, items: vec![] }
-          },
+            }
             Expression::Callable(func) => Primitive::Callable(func),
             Expression::Conditional { box cond, then_clause, else_clause } => {
                 let cond = self.expression(cond)?;
                 match cond {
                     Primitive::Literal(Literal::Bool(true)) => self.block(then_clause)?,
                     Primitive::Literal(Literal::Bool(false)) => self.block(else_clause)?,
-                  v => return Err(format!("Non-boolean value {:?} in if-statement", v).into())
+                    v => return Err(format!("Non-boolean value {:?} in if-statement", v).into()),
+                }
+            }
+            Expression::CaseMatch { box cond, alternatives } => {
+                self.case_match_expression(cond, alternatives)?
             }
-          },
-          Expression::CaseMatch { box cond, alternatives } => self.case_match_expression(cond, alternatives)?,
             Expression::ReductionError(e) => return Err(e.into()),
         })
     }
 
-  fn case_match_expression(&mut self, cond: Expression, alternatives: Vec<Alternative>) -> EvalResult<Primitive> {
+    fn case_match_expression(
+        &mut self,
+        cond: Expression,
+        alternatives: Vec<Alternative>,
+    ) -> EvalResult<Primitive> {
         fn matches(scrut: &Primitive, pat: &Pattern, scope: &mut ScopeStack<Memory, MemoryValue>) -> bool {
             match pat {
                 Pattern::Ignored => true,
@@ -283,26 +286,35 @@ impl<'a> State<'a> {
                     let mem = def_id.into();
                     scope.insert(mem, MemoryValue::Primitive(scrut.clone())); //TODO make sure this doesn't cause problems with nesting
                     true
-              },
+                }
-              Pattern::Literal(pat_literal) => if let Primitive::Literal(scrut_literal) = scrut {
+                Pattern::Literal(pat_literal) => {
+                    if let Primitive::Literal(scrut_literal) = scrut {
                         pat_literal == scrut_literal
                     } else {
                         false
-              },
+                    }
+                }
                 Pattern::Tuple { subpatterns, tag } => match tag {
                     None => match scrut {
-                      Primitive::Tuple(items) if items.len() == subpatterns.len() =>
+                        Primitive::Tuple(items) if items.len() == subpatterns.len() => items
-                          items.iter().zip(subpatterns.iter()).all(|(item, subpat)| matches(item, subpat, scope)),
+                            .iter()
-                      _ => false //TODO should be a type error
+                            .zip(subpatterns.iter())
+                            .all(|(item, subpat)| matches(item, subpat, scope)),
+                        _ => false, //TODO should be a type error
                     },
                     Some(pattern_tag) => match scrut {
                         //TODO should test type_ids for runtime type checking, once those work
-                      Primitive::Object { tag, items, .. } if tag == pattern_tag && items.len() == subpatterns.len() => {
+                        Primitive::Object { tag, items, .. }
-                          items.iter().zip(subpatterns.iter()).all(|(item, subpat)| matches(item, subpat, scope))
+                            if tag == pattern_tag && items.len() == subpatterns.len() =>
-                      }
+                        {
-                      _ => false
+                            items
-                  }
+                                .iter()
+                                .zip(subpatterns.iter())
+                                .all(|(item, subpat)| matches(item, subpat, scope))
                         }
+                        _ => false,
+                    },
+                },
             }
         }
         let cond = self.expression(cond)?;
@@ -310,11 +322,9 @@ impl<'a> State<'a> {
         for alt in alternatives.into_iter() {
             let mut new_scope = self.environments.new_scope(None);
             if matches(&cond, &alt.pattern, &mut new_scope) {
-              let mut new_state = State {
+                let mut new_state = State { environments: new_scope };
-                  environments: new_scope
-              };
 
-              return new_state.block(alt.item)
+                return new_state.block(alt.item);
             }
         }
         Err("No valid match in match expression".into())
@@ -333,30 +343,36 @@ impl<'a> State<'a> {
                     Some(MemoryValue::Function(FunctionDefinition { body })) => {
                         let body = body.clone(); //TODO ideally this clone would not happen
                         self.apply_function(body, args)
-                  },
-                  e => Err(format!("Error looking up function with id {}: {:?}", def_id, e).into())
                     }
-          },
+                    e => Err(format!("Error looking up function with id {}: {:?}", def_id, e).into()),
+                }
+            }
             Callable::Lambda { arity, body } => {
                 if arity as usize != args.len() {
-                  return Err(format!("Lambda expression requries {} arguments, only {} provided", arity, args.len()).into());
+                    return Err(format!(
+                        "Lambda expression requries {} arguments, only {} provided",
+                        arity,
+                        args.len()
+                    )
+                    .into());
                 }
                 self.apply_function(body, args)
             }
             Callable::DataConstructor { type_id, arity, tag } => {
                 if arity as usize != args.len() {
-                  return Err(format!("Constructor expression requries {} arguments, only {} provided", arity, args.len()).into());
+                    return Err(format!(
+                        "Constructor expression requries {} arguments, only {} provided",
+                        arity,
+                        args.len()
+                    )
+                    .into());
                 }
 
                 let mut evaluated_args: Vec<Primitive> = vec![];
                 for arg in args.into_iter() {
                     evaluated_args.push(self.expression(arg)?);
                 }
-              Ok(Primitive::Object {
+                Ok(Primitive::Object { type_id, tag, items: evaluated_args })
-                  type_id,
-                  tag,
-                  items: evaluated_args
-              })
             }
             Callable::RecordConstructor { type_id: _, tag: _ } => {
                 unimplemented!()
@@ -381,16 +397,16 @@ impl<'a> State<'a> {
             (IOPrint, &[ref anything]) => {
                 print!("{}", anything.to_repl());
                 Primitive::Tuple(vec![])
-          },
+            }
             (IOPrintLn, &[ref anything]) => {
                 print!("{}", anything.to_repl());
                 Primitive::Tuple(vec![])
-          },
+            }
             (IOGetLine, &[]) => {
                 let mut buf = String::new();
                 std::io::stdin().read_line(&mut buf).expect("Error readling line in 'getline'");
                 StringLit(Rc::new(buf.trim().to_string())).into()
-          },
+            }
             /* Binops */
             (binop, &[ref lhs, ref rhs]) => match (binop, lhs, rhs) {
                 // TODO need a better way of handling these literals
@@ -398,15 +414,19 @@ impl<'a> State<'a> {
                 (Add, Lit(Int(l)), Lit(Int(r))) => Int(l + r).into(),
                 (Add, Lit(Nat(l)), Lit(Int(r))) => Int((*l as i64) + (*r as i64)).into(),
                 (Add, Lit(Int(l)), Lit(Nat(r))) => Int((*l as i64) + (*r as i64)).into(),
-              (Concatenate, Lit(StringLit(ref s1)), Lit(StringLit(ref s2))) => StringLit(Rc::new(format!("{}{}", s1, s2))).into(),
+                (Concatenate, Lit(StringLit(ref s1)), Lit(StringLit(ref s2))) => {
+                    StringLit(Rc::new(format!("{}{}", s1, s2))).into()
+                }
                 (Subtract, Lit(Nat(l)), Lit(Nat(r))) => Nat(l - r).into(),
                 (Multiply, Lit(Nat(l)), Lit(Nat(r))) => Nat(l * r).into(),
                 (Divide, Lit(Nat(l)), Lit(Nat(r))) => Float((*l as f64) / (*r as f64)).into(),
-              (Quotient, Lit(Nat(l)), Lit(Nat(r))) => if *r == 0 {
+                (Quotient, Lit(Nat(l)), Lit(Nat(r))) => {
+                    if *r == 0 {
                         return Err("Divide-by-zero error".into());
                     } else {
                         Nat(l / r).into()
-              },
+                    }
+                }
                 (Modulo, Lit(Nat(l)), Lit(Nat(r))) => Nat(l % r).into(),
                 (Exponentiation, Lit(Nat(l)), Lit(Nat(r))) => Nat(l ^ r).into(),
                 (BitwiseAnd, Lit(Nat(l)), Lit(Nat(r))) => Nat(l & r).into(),
@@ -435,7 +455,9 @@ impl<'a> State<'a> {
                 (GreaterThanOrEqual, Lit(Int(l)), Lit(Int(r))) => Bool(l >= r).into(),
                 (GreaterThanOrEqual, Lit(Float(l)), Lit(Float(r))) => Bool(l >= r).into(),
 
-              (binop, lhs, rhs) => return Err(format!("Invalid binop expression {:?} {:?} {:?}", lhs, binop, rhs).into()),
+                (binop, lhs, rhs) => {
+                    return Err(format!("Invalid binop expression {:?} {:?} {:?}", lhs, binop, rhs).into())
+                }
             },
             (prefix, &[ref arg]) => match (prefix, arg) {
                 (BooleanNot, Lit(Bool(true))) => Bool(false),
@@ -445,8 +467,9 @@ impl<'a> State<'a> {
                 (Negate, Lit(Float(f))) => Float(-(*f as f64)),
                 (Increment, Lit(Int(n))) => Int(*n),
                 (Increment, Lit(Nat(n))) => Nat(*n),
-              _ => return Err("No valid prefix op".into())
+                _ => return Err("No valid prefix op".into()),
-          }.into(),
+            }
+            .into(),
             (x, args) => return Err(format!("bad or unimplemented builtin {:?} | {:?}", x, args).into()),
         })
     }
@@ -457,9 +480,7 @@ impl<'a> State<'a> {
             evaluated_args.push(self.expression(arg)?);
         }
 
-      let mut frame_state = State {
+        let mut frame_state = State { environments: self.environments.new_scope(None) };
-          environments: self.environments.new_scope(None)
-      };
 
         for (n, evaled) in evaluated_args.into_iter().enumerate() {
             let n = n as u8;
@@ -470,4 +491,3 @@ impl<'a> State<'a> {
         frame_state.block(body)
     }
 }
-

schala-lang/language/src/tree_walk_eval/test.rs

@@ -1,8 +1,7 @@
 #![cfg(test)]
 use test_case::test_case;
 
-use crate::symbol_table::SymbolTable;
+use crate::{symbol_table::SymbolTable, tree_walk_eval::State};
-use crate::tree_walk_eval::State;
 
 fn evaluate_input(input: &str) -> Result<String, String> {
     let ast = crate::util::quick_ast(input);
@@ -106,14 +105,16 @@ let d = if "xxx" is "yyy" then { 20 } else { 30 }
 #[test_case("cyrus", "4")]
 fn basic_patterns_2(input: &str, expected: &str) {
     let mut source = format!(r#"let x = "{}""#, input);
-    source.push_str(r#"
+    source.push_str(
+        r#"
 if x {
     is "sanchez" then 1
     is "mouri" then 2
     is "hella" then 3
     is _ then 4
 }
-"#);
+"#,
+    );
     eval_assert(&source, expected);
 }
 
@@ -121,12 +122,14 @@ if x {
 #[test_case(r#"(99, "panda", false, -2.45)"#, r#""maybe""#)]
 fn tuple_patterns(input: &str, expected: &str) {
     let mut source = format!("let x = {}", input);
-    source.push_str(r#"
+    source.push_str(
+        r#"
 if x {
     is (45, "pablo", _, 28.4) then "no"
     is (_, "panda", _, 2.2) then "yes"
     is _ then "maybe"
-}"#);
+}"#,
+    );
 
     eval_assert(&source, expected);
 }
@@ -230,7 +233,6 @@ if (1, 2) {
     eval_assert(source, "2");
 }
 
-
 #[test]
 fn tuple_pattern_2() {
     let source = r#"
@@ -264,7 +266,6 @@ if (1, 5) {
     eval_assert(source, "5");
 }
 
-
 #[test]
 fn prim_obj_pattern() {
     let source = r#"