Rename module and add comments

src/fun/parser.rs

@@ -495,18 +495,22 @@ impl<'a> TermParser<'a> {
         self.skip_trivia();
         let (cur_name, rule) = self.parse_rule()?;
         let mut rules = vec![rule];
+        // the current index to backtack in case of fail to parse the next rule.
         let mut nxt_term = *self.index();
         loop {
           self.skip_trivia();
+          // save the start position of the rule that can be a next def term.
           let nxt_def = *self.index();
           match self.parse_rule() {
             Ok((name, rule)) => {
               if name == "def" {
+                // parse the nxt def term.
                 self.index = nxt_def;
                 return Ok(Term::Def { nam: cur_name, rules, nxt: Box::new(self.parse_term()?) });
               }
               if name == cur_name {
                 rules.push(rule);
+                // save the current position.
                 nxt_term = *self.index();
               } else {
                 let cur = *self.index();
@@ -514,6 +518,7 @@ impl<'a> TermParser<'a> {
                 return self.with_ctx(Err(msg), nxt_def..cur);
               }
             }
+            // if failed it is a term.
             Err(_) => break self.index = nxt_term,
           }
         }

src/fun/transform/lift_local_defs.rs

@@ -5,12 +5,12 @@ use indexmap::IndexMap;
 use crate::fun::{Book, Definition, Name, Pattern, Rule, Term};
 
 impl Book {
-  pub fn lift_defs(&mut self) {
+  pub fn lift_local_defs(&mut self) {
     let mut defs = IndexMap::new();
     for (name, def) in self.defs.iter_mut() {
       let mut gen = 0;
       for rule in def.rules.iter_mut() {
-        rule.body.lift_defs(name, &mut defs, &mut gen);
+        rule.body.lift_local_defs(name, &mut defs, &mut gen);
       }
     }
     self.defs.extend(defs);
@@ -24,14 +24,14 @@ impl Rule {
 }
 
 impl Term {
-  pub fn lift_defs(&mut self, parent: &Name, defs: &mut IndexMap<Name, Definition>, gen: &mut usize) {
+  pub fn lift_local_defs(&mut self, parent: &Name, defs: &mut IndexMap<Name, Definition>, gen: &mut usize) {
     match self {
       Term::Def { nam, rules, nxt } => {
         let local_name = Name::new(format!("{}__local_{}_{}", parent, gen, nam));
         for rule in rules.iter_mut() {
-          rule.body.lift_defs(&local_name, defs, gen);
+          rule.body.lift_local_defs(&local_name, defs, gen);
         }
-        nxt.lift_defs(parent, defs, gen);
+        nxt.lift_local_defs(parent, defs, gen);
         *gen += 1;
 
         let inner_defs =
@@ -46,7 +46,7 @@ impl Term {
       }
       _ => {
         for child in self.children_mut() {
-          child.lift_defs(parent, defs, gen);
+          child.lift_local_defs(parent, defs, gen);
         }
       }
     }

src/fun/transform/mod.rs

@@ -14,7 +14,7 @@ pub mod expand_main;
 pub mod fix_match_defs;
 pub mod fix_match_terms;
 pub mod float_combinators;
-pub mod lift_defs;
+pub mod lift_local_defs;
 pub mod linearize_matches;
 pub mod linearize_vars;
 pub mod resolve_refs;

src/lib.rs

@@ -90,7 +90,7 @@ pub fn desugar_book(
 
   ctx.set_entrypoint();
 
-  ctx.book.lift_defs();
+  ctx.book.lift_local_defs();
 
   ctx.book.encode_adts(opts.adt_encoding);