bend-lang 0.2.38

A high-level, massively parallel programming language
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

use crate::{
  diagnostics::Diagnostics,
  fun::{Adts, Ctx, Term},
  maybe_grow,
};

impl Ctx<'_> {
  pub fn desugar_open(&mut self) -> Result<(), Diagnostics> {
    for def in self.book.defs.values_mut() {
      for rule in def.rules.iter_mut() {
        if let Err(err) = rule.body.desugar_open(&self.book.adts) {
          self.info.add_function_error(err, def.name.clone(), def.source.clone());
        }
      }
    }

    self.info.fatal(())
  }
}

impl Term {
  fn desugar_open(&mut self, adts: &Adts) -> Result<(), String> {
    maybe_grow(|| {
      match self {
        Term::Open { typ, var, bod } => {
          bod.desugar_open(adts)?;
          if let Some(adt) = adts.get(&*typ) {
            if adt.ctrs.len() == 1 {
              let ctr = adt.ctrs.keys().next().unwrap();
              *self = Term::Mat {
                arg: Box::new(Term::Var { nam: var.clone() }),
                bnd: Some(std::mem::take(var)),
                with_bnd: vec![],
                with_arg: vec![],
                arms: vec![(Some(ctr.clone()), vec![], std::mem::take(bod))],
              }
            } else {
              return Err(format!("Type '{typ}' of an 'open' has more than one constructor"));
            }
          } else {
            return Err(format!("Type '{typ}' of an 'open' is not defined"));
          }
        }
        Term::Def { def, nxt } => {
          for rule in def.rules.iter_mut() {
            rule.body.desugar_open(adts)?;
          }
          nxt.desugar_open(adts)?;
        }
        _ => {
          for child in self.children_mut() {
            child.desugar_open(adts)?;
          }
        }
      }
      Ok(())
    })
  }
}