rustfmt.toml

@@ -1,8 +0,0 @@
-
-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,6 +2,7 @@
 #![allow(clippy::enum_variant_names)]
 
 use std::rc::Rc;
+use std::fmt;
 use std::convert::{AsRef, From};
 
 mod visitor;
@@ -12,19 +13,41 @@ pub use visitor::*;
 
 use crate::derivative::Derivative;
 use crate::tokenizing::Location;
-use crate::identifier::{Id, define_id_kind};
 
-define_id_kind!(ASTItem);
-
-/*
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Default)]
-pub struct ASTItem;
-impl IdKind for ASTItem {
-    fn tag() -> &'static str { "ASTItem" }
+/// An abstract identifier for an AST node. Note that
+/// 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,
 }
-*/
 
-pub type ItemId = Id<ASTItem>;
+impl ItemId {
+  fn new(n: u32) -> ItemId {
+    ItemId { idx: n }
+  }
+}
+
+impl fmt::Display for ItemId {
+  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

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

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

@@ -14,10 +14,42 @@ mod resolver;
 mod symbol_trie;
 use symbol_trie::SymbolTrie;
 mod test;
-use crate::identifier::{Id, IdStore, define_id_kind};
 
-define_id_kind!(DefItem);
-pub type DefId = Id<DefItem>;
+
+//TODO parameterize different types of ID
+/// 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)]
@@ -138,7 +170,7 @@ impl<K> NameTable<K> {
 //cf. p. 150 or so of Language Implementation Patterns
 pub struct SymbolTable {
 
-    def_id_store: IdStore<DefItem>,
+    def_id_store: DefIdStore,
 
     /// Used for import resolution.
     symbol_trie: SymbolTrie,
@@ -158,7 +190,7 @@ pub struct SymbolTable {
 impl SymbolTable {
     pub fn new() -> SymbolTable {
         SymbolTable {
-            def_id_store: IdStore::new(),
+            def_id_store: DefIdStore::new(),
             symbol_trie: SymbolTrie::new(),
             fq_names: NameTable::new(),
             types: NameTable::new(),

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

@@ -1,14 +1,12 @@
-use std::{convert::From, fmt::Write, rc::Rc};
+use crate::reduced_ir::{ReducedIR, Expression, Lookup, Callable, FunctionDefinition, Statement, Literal, Alternative, Pattern};
+use crate::symbol_table::{DefId};
+use crate::util::ScopeStack;
+use crate::builtin::Builtin;
+use crate::typechecking::TypeId;
 
-use crate::{
-    builtin::Builtin,
-    reduced_ir::{
-        Alternative, Callable, Expression, FunctionDefinition, Literal, Lookup, Pattern, ReducedIR, Statement,
-    },
-    symbol_table::DefId,
-    typechecking::TypeId,
-    util::ScopeStack,
-};
+use std::fmt::Write;
+use std::rc::Rc;
+use std::convert::From;
 
 mod test;
 
@@ -23,7 +21,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
@@ -41,18 +39,22 @@ impl From<&DefId> for Memory {
 
 #[derive(Debug)]
 struct RuntimeError {
-    msg: String,
+    msg: String
 }
 
 impl From<String> for RuntimeError {
     fn from(msg: String) -> Self {
-        Self { msg }
+        Self {
+            msg
+        }
     }
 }
 
 impl From<&str> for RuntimeError {
     fn from(msg: &str) -> Self {
-        Self { msg: msg.to_string() }
+        Self {
+            msg: msg.to_string(),
+        }
     }
 }
 
@@ -63,7 +65,7 @@ impl RuntimeError {
     }
 }
 
-fn paren_wrapped(terms: impl Iterator<Item = String>) -> String {
+fn paren_wrapped(terms: impl Iterator<Item=String>) -> String {
   let mut buf = String::new();
   write!(buf, "(").unwrap();
   for term in terms.map(Some).intersperse(None) {
@@ -90,6 +92,7 @@ impl From<Primitive> for MemoryValue {
     }
 }
 
+
 impl MemoryValue {
     fn to_repl(&self) -> String {
         match self {
@@ -123,23 +126,26 @@ enum Primitive {
     Tuple(Vec<Primitive>),
     Literal(Literal),
     Callable(Callable),
-    Object { type_id: TypeId, tag: u32, items: Vec<Primitive> },
+    Object {
+        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, .. } => {
-                format!("{}{}", type_id.local_name(), paren_wrapped(items.iter().map(|item| item.to_repl())))
-            }
+            Primitive::Object { type_id, items, .. } =>
+                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(),
         }
@@ -158,7 +164,9 @@ impl From<Literal> for Primitive {
 
 impl<'a> State<'a> {
     pub fn new() -> Self {
-        Self { environments: ScopeStack::new(Some("global".to_string())) }
+        Self {
+            environments: ScopeStack::new(Some("global".to_string()))
+        }
     }
 
     pub fn evaluate(&mut self, reduced: ReducedIR, repl: bool) -> Vec<Result<String, String>> {
@@ -171,7 +179,9 @@ impl<'a> State<'a> {
 
         for statement in reduced.entrypoint.into_iter() {
             match self.statement(statement) {
-                Ok(Some(output)) if repl => acc.push(Ok(output.to_repl())),
+                Ok(Some(output)) if repl => {
+                    acc.push(Ok(output.to_repl()))
+                },
                 Ok(_) => (),
                 Err(error) => {
                     acc.push(Err(error.msg));
@@ -190,7 +200,11 @@ impl<'a> State<'a> {
                 ret = Some(prim);
             }
         }
-        Ok(if let Some(ret) = ret { ret } else { self.expression(Expression::unit())? })
+        Ok(if let Some(ret) = ret {
+            ret
+        } else {
+            self.expression(Expression::unit())?
+        })
     }
 
     fn statement(&mut self, stmt: Statement) -> EvalResult<Option<MemoryValue>> {
@@ -200,7 +214,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()))
@@ -211,74 +225,57 @@ 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 { type_id, tag, items: vec![] }
-            }
+          Expression::Callable(Callable::DataConstructor { type_id, arity, tag }) if arity == 0 => 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()),
-                }
-            }
-            Expression::CaseMatch { box cond, alternatives } => {
-                self.case_match_expression(cond, alternatives)?
+                  v => return Err(format!("Non-boolean value {:?} in if-statement", v).into())
               }
+          },
+          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,
@@ -286,35 +283,26 @@ 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() => items
-                            .iter()
-                            .zip(subpatterns.iter())
-                            .all(|(item, subpat)| matches(item, subpat, scope)),
-                        _ => false, //TODO should be a type error
+                      Primitive::Tuple(items) if items.len() == subpatterns.len() =>
+                          items.iter().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() =>
-                        {
-                            items
-                                .iter()
-                                .zip(subpatterns.iter())
-                                .all(|(item, subpat)| matches(item, subpat, scope))
+                      Primitive::Object { tag, items, .. } if tag == pattern_tag && items.len() == subpatterns.len() => {
+                          items.iter().zip(subpatterns.iter()).all(|(item, subpat)| matches(item, subpat, scope))
+                      }
+                      _ => false
+                  }
               }
-                        _ => false,
-                    },
-                },
           }
       }
       let cond = self.expression(cond)?;
@@ -322,9 +310,11 @@ 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 { environments: new_scope };
+              let mut new_state = State {
+                  environments: new_scope
+              };
 
-                return new_state.block(alt.item);
+              return new_state.block(alt.item)
           }
       }
       Err("No valid match in match expression".into())
@@ -343,36 +333,30 @@ 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 { type_id, tag, items: evaluated_args })
+              Ok(Primitive::Object {
+                  type_id,
+                  tag,
+                  items: evaluated_args
+              })
           }
           Callable::RecordConstructor { type_id: _, tag: _ } => {
               unimplemented!()
@@ -397,16 +381,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
@@ -414,19 +398,15 @@ 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 {
+              (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 {
                   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(),
@@ -455,9 +435,7 @@ 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),
@@ -467,9 +445,8 @@ 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()),
-            }
-            .into(),
+              _ => return Err("No valid prefix op".into())
+          }.into(),
           (x, args) => return Err(format!("bad or unimplemented builtin {:?} | {:?}", x, args).into()),
       })
   }
@@ -480,7 +457,9 @@ impl<'a> State<'a> {
           evaluated_args.push(self.expression(arg)?);
       }
 
-        let mut frame_state = State { environments: self.environments.new_scope(None) };
+      let mut frame_state = State {
+          environments: self.environments.new_scope(None)
+      };
 
       for (n, evaled) in evaluated_args.into_iter().enumerate() {
           let n = n as u8;
@@ -491,3 +470,4 @@ impl<'a> State<'a> {
       frame_state.block(body)
   }
 }
+

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

@@ -1,7 +1,8 @@
 #![cfg(test)]
 use test_case::test_case;
 
-use crate::{symbol_table::SymbolTable, tree_walk_eval::State};
+use crate::symbol_table::SymbolTable;
+use crate::tree_walk_eval::State;
 
 fn evaluate_input(input: &str) -> Result<String, String> {
   let ast = crate::util::quick_ast(input);
@@ -88,7 +89,7 @@ fn basic_if_statement() {
 
 #[test]
 fn basic_patterns_1() {
-    let source = r#"
+    let source =r#"
 let x = 10
 let a = if x is 10 then { 255 } else { 256 }
 let b = if 23 is 99 then { 255 } else { 256 }
@@ -105,16 +106,14 @@ 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);
 }
 
@@ -122,14 +121,12 @@ 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);
 }
@@ -233,6 +230,7 @@ if (1, 2) {
     eval_assert(source, "2");
 }
 
+
 #[test]
 fn tuple_pattern_2() {
   let source = r#"
@@ -266,6 +264,7 @@ if (1, 5) {
     eval_assert(source, "5");
 }
 
+
 #[test]
 fn  prim_obj_pattern() {
   let source = r#"
@@ -306,7 +305,7 @@ let y = \(m, n, o) { m + n + o }(1,2,3)
 (x, y)
 "#;
 
-    eval_assert(source, r"(10, 6)");
+eval_assert(source, r"(10, 6)");
 }
 
 #[test]
@@ -319,7 +318,7 @@ milta()(10)
   "#;
 
   eval_assert(source, "43");
-}
+  }
 
 #[test]
 fn import_all() {