feat: for can iterate over ranges, compile-time values, or arrays

src/compiler/common.rs

@@ -205,13 +205,11 @@ impl FuncVerifier<AstNode> for Form {
     fn validate_types(&self, args: &[AstNode]) -> Result<()> {
         match self {
             Form::For => {
-                if matches!(args[0].class, Token::Symbol(_))
-                    && matches!(args[1].class, Token::Range(_))
-                {
+                if matches!(args[0].class, Token::Symbol(_)) {
                     Ok(())
                 } else {
                     bail!(
-                        "`{:?}` expects [SYMBOL RANGE EXPR] but received {:?}",
+                        "`{:?}` expects [SYMBOL ITERABLE EXPR] but received {:?}",
                         self,
                         args
                     )

src/compiler/generator.rs

@@ -17,7 +17,6 @@ use std::fmt::Debug;
 use std::io::Write;
 
 use std::sync::atomic::AtomicUsize;
-use std::{unimplemented, unreachable};
 
 use super::node::ColumnRef;
 use super::tables::{ComputationTable, Scope};
@@ -956,17 +955,33 @@ fn apply_form(
 
     match f {
         Form::For => {
-            if let (Token::Symbol(i_name), Token::Range(is), body) =
-                (&args[0].class, &args[1].class, &args[2])
-            {
+            if let (Token::Symbol(i_name), range, body) = (&args[0].class, &args[1], &args[2]) {
+                let is = match &range.class {
+                    // a for can iterate over an explicit range...
+                    Token::Range(is) => is.to_owned(),
+                    // ...or over [1..<compile-time evaluable value>]
+                    _ => {
+                        if let Some(range_exp) = reduce(&range, ctx, settings)? {
+                            if let Expression::ArrayColumn { domain, .. } = range_exp.e() {
+                                domain.iter().map(|&i| i as isize).collect::<Vec<_>>()
+                            } else {
+                                let k = range_exp.pure_eval()?.to_isize().unwrap();
+                                (1..=k).collect::<Vec<_>>()
+                            }
+                        } else {
+                            bail!("unable to iterate over {}", &range)
+                        }
+                    }
+                };
+
                 let mut l = vec![];
                 let mut t = Type::INFIMUM;
                 for i in is {
                     let mut for_ctx = ctx.derive(&uniquify(format!("{}-for-{}", ctx.name(), i)))?;
 
                     for_ctx.insert_symbol(
                         i_name,
-                        Expression::Const(BigInt::from(*i), Fr::from_str(&i.to_string())).into(),
+                        Expression::Const(BigInt::from(i), Fr::from_str(&i.to_string())).into(),
                     )?;
 
                     if let Some(r) = reduce(&body.clone(), &mut for_ctx, settings)? {
@@ -1246,7 +1261,7 @@ pub fn reduce(e: &AstNode, ctx: &mut Scope, settings: &CompileSettings) -> Resul
                                     .build(),
                             ))
                         } else {
-                            bail!("tried to access `{}` at index {}", array.pretty(), i)
+                            bail!("tried to access {} at index {}", array.pretty().bold(), i)
                         }
                     }
                     _ => unimplemented!(),

src/compiler/parser.rs

@@ -1167,7 +1167,7 @@ fn rec_parse(pair: Pair<Rule>) -> Result<AstNode> {
                 (Some(start), Some(stop), Some(step)) => {
                     (start..=stop).step_by(step.try_into()?).collect()
                 }
-                x => unimplemented!("{:?}", x),
+                x => unimplemented!("{} -> {:?}", src, x),
             };
             Ok(AstNode {
                 class: Token::Range(range),

src/corset.pest

@@ -13,7 +13,7 @@ nth = { "[" ~ symbol ~ expr ~ "]" }
 
 range = _{ immediate_range | interval }
 immediate_range = { "{" ~ integer+ ~ "}" }
-interval = { "[" ~ ((natural ~ (":" ~ natural ~ (":" ~ natural)?)?) | expr) ~ "]" }
+interval = { "[" ~ (natural ~ (":" ~ natural ~ (":" ~ natural)?)?) ~ "]" }
 
 integer = @{ "-"? ~ natural }
 natural = @{ "0x" ~ ASCII_HEX_DIGIT+ | "0b" ~ ASCII_BIN_DIGIT+ | ASCII_DIGIT+ }

src/exporters/debugger.rs

@@ -168,7 +168,7 @@ fn render_constraints(
                 } => {
                     let mut tty = Tty::new();
                     pretty_expr(expr, None, &mut tty, show_types);
-                    println!("\n{}", handle.pretty());
+                    println!("\n- {}:", handle.pretty());
                     println!("{}", tty.page_feed());
                 }
                 Constraint::Plookup {

tests/for.lisp

@@ -1,11 +1,11 @@
-(defcolumns A (B :ARRAY [1:10]))
+(defcolumns A (B :ARRAY [4:14]))
 
-(defconstraint test1 () (for i {1 2 3} (eq! A [B i])))
+(defconstraint test1 () (for i {4 5 6} (eq! A [B i])))
 
-(defconstraint test2 () (for i [(length B)] (eq! A [B i])))
+(defconstraint test2 () (for i B (eq! A [B i])))
 
-(defconstraint test3 () (for i [1:5]
-                          (for j {2 4 6}
+(defconstraint test3 () (for i [10:14]
+                          (for j {4 6 8}
                                (for k {1 5} (eq! [B i] [B j])))))
 
-(defconstraint test4 () (for i [5] (vanishes! (shift [B i] 1))))
+(defconstraint test4 () (for i [5:10] (vanishes! (shift [B i] 1))))