list and table interpolation

talc-lang/src/chunk.rs

@@ -134,8 +134,10 @@ pub enum Instruction {
 
 	NewList(u8),
 	GrowList(u8),
+	ExtendList,
 	NewTable(u8),
 	GrowTable(u8),
+	ExtendTable,
 
 	Index,
 	StoreIndex,
@@ -197,8 +199,10 @@ impl std::fmt::Display for Instruction {
 			Self::BinaryOp(o) => write!(f, "binary {o:?}"),
 			Self::NewList(n) => write!(f, "newlist #{n}"),
 			Self::GrowList(n) => write!(f, "growlist #{n}"),
+			Self::ExtendList => write!(f, "extendlist"),
 			Self::NewTable(n) => write!(f, "newtable #{n}"),
 			Self::GrowTable(n) => write!(f, "growtable #{n}"),
+			Self::ExtendTable => write!(f, "extendtable"),
 			Self::Index => write!(f, "index"),
 			Self::StoreIndex => write!(f, "storeindex"),
 			Self::Jump(a) => write!(f, "jump @{}", usize::from(a)),

talc-lang/src/compiler.rs

@@ -3,11 +3,12 @@ use std::collections::HashMap;
 use std::rc::Rc;
 
 use crate::chunk::{Arg24, Catch, Chunk, Instruction as I};
-use crate::parser::ast::{BinaryOp, CatchBlock, Expr, ExprKind, LValue, LValueKind};
+use crate::parser::ast::{
+	BinaryOp, CatchBlock, Expr, ExprKind, LValue, LValueKind, ListItem, TableItem,
+};
 use crate::parser::Pos;
 use crate::prelude::*;
 use crate::symbol::{Symbol, SYM_REPL, SYM_SELF};
-use crate::throw;
 use crate::value::function::{FuncAttrs, Function};
 use crate::value::Value;
 
@@ -460,41 +461,8 @@ impl<'a> Compiler<'a> {
 					self.declare_global(*name);
 				}
 			}
-			ExprKind::List(xs) if xs.is_empty() => {
+			ExprKind::List(xs) => self.expr_list(xs)?,
-				self.emit(I::NewList(0));
+			ExprKind::Table(xs) => self.expr_table(xs)?,
-			}
-			ExprKind::List(xs) => {
-				let mut first = true;
-				for chunk in xs.chunks(16) {
-					for e in chunk {
-						self.expr(e)?;
-					}
-					if first {
-						self.emit(I::NewList(chunk.len() as u8));
-						first = false;
-					} else {
-						self.emit(I::GrowList(chunk.len() as u8));
-					}
-				}
-			}
-			ExprKind::Table(xs) if xs.is_empty() => {
-				self.emit(I::NewTable(0));
-			}
-			ExprKind::Table(xs) => {
-				let mut first = true;
-				for chunk in xs.chunks(8) {
-					for (k, v) in chunk {
-						self.expr(k)?;
-						self.expr(v)?;
-					}
-					if first {
-						self.emit(I::NewTable(chunk.len() as u8));
-						first = false;
-					} else {
-						self.emit(I::GrowTable(chunk.len() as u8));
-					}
-				}
-			}
 			ExprKind::Index(ct, idx) => {
 				self.expr(ct)?;
 				self.expr(idx)?;
@@ -600,6 +568,83 @@ impl<'a> Compiler<'a> {
 		Ok(())
 	}
 
+	fn expr_list(&mut self, xs: &[ListItem]) -> Result<()> {
+		if xs.is_empty() {
+			self.emit(I::NewList(0));
+			return Ok(())
+		}
+		fn finish_chunk(c: &mut Compiler, len: &mut usize, first: &mut bool) {
+			if *first {
+				c.emit(I::NewList(*len as u8));
+				*first = false;
+			} else {
+				if *len == 0 {
+					return
+				}
+				c.emit(I::GrowList(*len as u8));
+			}
+			*len = 0;
+		}
+		let mut first = true;
+		let mut chlen = 0;
+		for (i, e) in xs.iter().enumerate() {
+			match e {
+				ListItem::Interpolate(e) => {
+					finish_chunk(self, &mut chlen, &mut first);
+					self.expr(e)?;
+					self.emit(I::ExtendList);
+				}
+				ListItem::Item(e) => {
+					self.expr(e)?;
+					chlen += 1;
+					if chlen >= 16 || i == xs.len() - 1 {
+						finish_chunk(self, &mut chlen, &mut first);
+					}
+				}
+			}
+		}
+		Ok(())
+	}
+
+	fn expr_table(&mut self, xs: &[TableItem]) -> Result<()> {
+		if xs.is_empty() {
+			self.emit(I::NewTable(0));
+			return Ok(())
+		}
+		fn finish_chunk(c: &mut Compiler, len: &mut usize, first: &mut bool) {
+			if *first {
+				c.emit(I::NewTable(*len as u8));
+				*first = false;
+			} else {
+				if *len == 0 {
+					return
+				}
+				c.emit(I::GrowTable(*len as u8));
+			}
+			*len = 0;
+		}
+		let mut first = true;
+		let mut chlen = 0;
+		for (i, e) in xs.iter().enumerate() {
+			match e {
+				TableItem::Pair(k, v) => {
+					self.expr(k)?;
+					self.expr(v)?;
+					chlen += 1;
+					if chlen >= 8 || i == xs.len() - 1 {
+						finish_chunk(self, &mut chlen, &mut first);
+					}
+				}
+				TableItem::Interpolate(ext) => {
+					finish_chunk(self, &mut chlen, &mut first);
+					self.expr(ext)?;
+					self.emit(I::ExtendTable);
+				}
+			}
+		}
+		Ok(())
+	}
+
 	fn expr_infinite_loop(&mut self, body: &Expr) -> Result<()> {
 		let start = self.ip();
 		self.begin_break_frame();

talc-lang/src/optimize.rs

@@ -1,7 +1,7 @@
 use core::panic;
 
 use crate::{
-	parser::ast::{CatchBlock, Expr, ExprKind, LValue, LValueKind},
+	parser::ast::{CatchBlock, Expr, ExprKind, LValue, LValueKind, ListItem, TableItem},
 	value::Value,
 	vm,
 };
@@ -128,14 +128,24 @@ fn optimize_ex_with(expr: &mut Expr, state: OptState) {
 		}
 		ExprKind::List(xs) => {
 			for e in xs {
-				optimize_ex(e);
+				match e {
+					ListItem::Item(e) => optimize_ex(e),
+					ListItem::Interpolate(e) => optimize_ex(e),
+				}
 			}
 		}
 		ExprKind::Table(t) => {
-			for (k, v) in t {
+			for e in t {
+				match e {
+					TableItem::Pair(k, v) => {
 						optimize_ex(k);
 						optimize_ex(v);
 					}
+					TableItem::Interpolate(ext) => {
+						optimize_ex(ext);
+					}
+				}
+			}
 		}
 		ExprKind::Return(e) => {
 			if let Some(e) = e {

talc-lang/src/parser/ast.rs

@@ -65,8 +65,8 @@ pub enum ExprKind {
 	Pipe(Box<Expr>, Box<Expr>),
 
 	Block(Vec<Expr>),
-	List(Vec<Expr>),
+	List(Vec<ListItem>),
-	Table(Vec<(Expr, Expr)>),
+	Table(Vec<TableItem>),
 
 	Return(Option<Box<Expr>>),
 	Break(Option<Box<Expr>>),
@@ -90,6 +90,18 @@ impl ExprKind {
 	}
 }
 
+#[derive(Debug)]
+pub enum TableItem {
+	Pair(Box<Expr>, Box<Expr>),
+	Interpolate(Box<Expr>),
+}
+
+#[derive(Debug)]
+pub enum ListItem {
+	Item(Box<Expr>),
+	Interpolate(Box<Expr>),
+}
+
 #[derive(Debug)]
 pub struct CatchBlock {
 	pub span: Span,
@@ -258,16 +270,32 @@ impl Expr {
 			ExprKind::List(l) => {
 				writeln!(w, "list")?;
 				for e in l {
+					match e {
+						ListItem::Item(e) => {
 							e.write_to(w, depth)?;
 						}
+						ListItem::Interpolate(ext) => {
+							writeln!(w, "{0: >1$}interpolate", "", depth * 2)?;
+							ext.write_to(w, depth + 1)?;
+						}
+					}
+				}
 				Ok(())
 			}
 			ExprKind::Table(t) => {
-				writeln!(w, "list")?;
+				writeln!(w, "table")?;
-				for (k, v) in t {
+				for e in t {
+					match e {
+						TableItem::Pair(k, v) => {
 							k.write_to(w, depth)?;
 							v.write_to(w, depth)?;
 						}
+						TableItem::Interpolate(ext) => {
+							writeln!(w, "{0: >1$}interpolate", "", depth * 2)?;
+							ext.write_to(w, depth + 1)?;
+						}
+					}
+				}
 				Ok(())
 			}
 			ExprKind::Return(e) => {

talc-lang/src/parser/parser.rs

@@ -1,12 +1,13 @@
 use std::iter::Peekable;
 
 use crate::{
+	parser::ast::TableItem,
 	symbol::{Symbol, SYM_DOLLAR_SIGN},
 	value::Value,
 };
 
 use super::{
-	ast::{BinaryOp, CatchBlock, Expr, ExprKind, LValue, UnaryOp},
+	ast::{BinaryOp, CatchBlock, Expr, ExprKind, LValue, ListItem, UnaryOp},
 	parse_float, parse_int_literal, parse_str_escapes, Lexer, ParserError, Span,
 	SpanParserError, Token, TokenKind,
 };
@@ -204,21 +205,53 @@ impl<'s> Parser<'s> {
 		self.lexer.peek().unwrap().clone()
 	}
 
-	fn parse_table_items(&mut self) -> Result<Vec<(Expr, Expr)>> {
+	fn parse_table_items(&mut self) -> Result<Vec<TableItem>> {
 		let mut items = Vec::new();
-		while self.peek()?.kind.expr_first() {
+		loop {
-			let key = if let Some(id) = try_next!(self, T::Identifier) {
+			let t = self.peek()?;
-				E::Literal(Symbol::get(id.content).into()).span(id.span)
+			match t.kind {
-			} else {
+				T::Identifier => {
-				self.parse_term_not_ident()?
+					self.next()?;
-			};
+					let key = E::Literal(Symbol::get(t.content).into()).span(t.span);
-
 					expect!(self, T::Equal);
-
 					let value = self.parse_expr()?;
+					items.push(TableItem::Pair(b(key), b(value)));
+				}
+				T::DotDot => {
+					self.next()?;
+					let ext = self.parse_expr()?;
+					items.push(TableItem::Interpolate(b(ext)));
+				}
+				k if k.expr_first() => {
+					let key = self.parse_term_not_ident()?;
+					expect!(self, T::Equal);
+					let value = self.parse_expr()?;
+					items.push(TableItem::Pair(b(key), b(value)));
+				}
+				_ => break,
+			}
+			if try_next!(self, T::Comma).is_none() {
+				break
+			}
+		}
+		Ok(items)
+	}
 
-			items.push((key, value));
+	fn parse_list_items(&mut self) -> Result<Vec<ListItem>> {
-
+		let mut items = Vec::new();
+		loop {
+			let t = self.peek()?;
+			match t.kind {
+				T::DotDot => {
+					self.next()?;
+					let expr = self.parse_expr()?;
+					items.push(ListItem::Interpolate(b(expr)));
+				}
+				k if k.expr_first() => {
+					items.push(ListItem::Item(b(self.parse_expr()?)));
+				}
+				_ => break,
+			}
 			if try_next!(self, T::Comma).is_none() {
 				break
 			}
@@ -325,7 +358,7 @@ impl<'s> Parser<'s> {
 				Ok(e)
 			}
 			T::LBrack => {
-				let args = self.parse_expr_list()?;
+				let args = self.parse_list_items()?;
 				let end = expect!(self, T::RBrack);
 				Ok(E::List(args).span(tok.span + end.span))
 			}

talc-lang/src/vm.rs

@@ -16,7 +16,7 @@ use crate::{
 	},
 	value::{
 		function::{FuncAttrs, Function, NativeFunc},
-		Value,
+		HashValue, Value,
 	},
 };
 
@@ -240,6 +240,12 @@ impl Vm {
 		self.stack.pop().expect("temporary stack underflow")
 	}
 
+	#[inline]
+	fn take_n(&mut self, n: usize) -> Value {
+		let i = self.stack.len() - n - 1;
+		std::mem::take(&mut self.stack[i])
+	}
+
 	#[inline]
 	fn pop_n(&mut self, n: usize) -> Vec<Value> {
 		let res = self.stack.split_off(self.stack.len() - n);
@@ -397,38 +403,86 @@ impl Vm {
 				list.borrow_mut().extend(ext);
 				self.push(Value::List(list));
 			}
+			// [l,e] -> [l ++ e]
+			I::ExtendList => {
+				let ext = self.pop();
+				let list = self.pop(); // must be a list
+				let Value::List(list) = list else {
+					panic!("not a list")
+				};
+				match ext {
+					Value::List(ext) => {
+						list.borrow_mut().extend_from_slice(ext.borrow().as_slice());
+					}
+					_ => {
+						let mut list = list.borrow_mut();
+						let f = ext.to_iter_function()?;
+						loop {
+							self.push(f.clone());
+							self.instr_call(0, frame)?;
+							match self.pop().iter_unpack() {
+								None => break,
+								Some(v) => list.push(v),
+							}
+						}
+					}
+				}
+				self.push(Value::List(list));
+			}
 			// [k0,v0...kn,vn] -.> [{k0=v0...kn=vn}]
 			I::NewTable(n) => {
+				let n = n as usize;
 				let mut table = HashMap::new();
-				for _ in 0..n {
+				for i in 0..n {
-					let v = self.pop();
+					let k: HashValue = self.take_n(2 * (n - i - 1) + 1).try_into()?;
-					let k = self.pop();
+					let v = self.take_n(2 * (n - i - 1));
 					if v == Value::Nil {
-						table.remove(&k.try_into()?);
+						table.remove(&k);
 					} else {
-						table.insert(k.try_into()?, v);
+						table.insert(k, v);
 					}
 				}
+				self.stack.truncate(self.stack.len() - 2 * n);
 				self.push(table.into());
 			}
 			// [t,k0,v0...kn,vn] -> [t ++ {k0=v0...kn=vn}]
 			I::GrowTable(n) => {
-				let mut ext = self.pop_n(2 * n as usize);
+				let n = n as usize;
-				let table = self.pop();
+				let table = self.take_n(2 * n);
 				let Value::Table(table) = table else {
 					panic!("not a table")
 				};
 				let mut table_ref = table.borrow_mut();
-				for _ in 0..n {
+				for i in 0..n {
-					// can't panic: pop_n checked that ext would have len 2*n
+					let k: HashValue = self.take_n(2 * (n - i - 1) + 1).try_into()?;
-					let v = ext.pop().unwrap();
+					let v = self.take_n(2 * (n - i - 1));
-					let k = ext.pop().unwrap();
 					if v == Value::Nil {
-						table_ref.remove(&k.try_into()?);
+						table_ref.remove(&k);
 					} else {
-						table_ref.insert(k.try_into()?, v);
+						table_ref.insert(k, v);
 					}
 				}
+				self.stack.truncate(self.stack.len() - 2 * n - 1);
+				drop(table_ref);
+				self.push(Value::Table(table));
+			}
+			I::ExtendTable => {
+				let ext = self.pop();
+				let table = self.pop(); // must be a list
+				let Value::Table(table) = table else {
+					panic!("not a table")
+				};
+				let Value::Table(ext) = ext else {
+					throw!(
+						*SYM_TYPE_ERROR,
+						"cannot interpolate value {:#} into table",
+						ext
+					)
+				};
+				let mut table_ref = table.borrow_mut();
+				for (k, v) in ext.borrow().iter() {
+					table_ref.insert(k.clone(), v.clone());
+				}
 				drop(table_ref);
 				self.push(Value::Table(table));
 			}
@@ -493,58 +547,7 @@ impl Vm {
 				frame.try_frames.pop().expect("no try to pop");
 			}
 			// [f,a0,a1...an] -> [f(a0,a1...an)]
-			I::Call(n) => {
+			I::Call(n) => self.instr_call(n as usize, frame)?,
-				self.check_interrupt()?;
-				let n = usize::from(n);
-
-				let args = self.pop_n(n + 1);
-
-				let args = match get_call_outcome(args)? {
-					CallOutcome::Call(args) => args,
-					CallOutcome::Partial(v) => {
-						self.push(v);
-						return Ok(None)
-					}
-				};
-
-				if let Value::NativeFunc(nf) = &args[0] {
-					let nf = nf.clone();
-
-					// safety: frame is restored immediately
-					// after function call ends
-					// ~25% performance improvement in
-					// code heavy on native function calls
-					unsafe {
-						let f = std::ptr::read(frame);
-						self.call_stack.push(f);
-					}
-
-					let res = (nf.func)(self, args);
-
-					// safety: frame was referencing invalid memory due to
-					// previous unsafe block, write will fix that
-					unsafe {
-						let f = self.call_stack.pop().expect("no frame to pop");
-						std::ptr::write(frame, f);
-					}
-
-					// make sure we restored the value of frame
-					// before propagating exceptions
-					let res = res?;
-
-					self.push(res);
-				} else if let Value::Function(func) = &args[0] {
-					if self.call_stack.len() + 1 >= self.stack_max {
-						throw!(*SYM_CALL_STACK_OVERFLOW, "call stack overflow")
-					}
-
-					let new_frame = CallFrame::new(func.clone(), args);
-					let old_frame = std::mem::replace(frame, new_frame);
-					self.call_stack.push(old_frame);
-				} else {
-					unreachable!("already verified by calling get_call_type");
-				}
-			}
 			// [f,a0,a1...an] -> [], return f(a0,a1...an)
 			I::Tail(n) => {
 				self.check_interrupt()?;
@@ -594,6 +597,60 @@ impl Vm {
 
 		Ok(None)
 	}
+
+	fn instr_call(&mut self, n: usize, frame: &mut CallFrame) -> Result<()> {
+		self.check_interrupt()?;
+
+		let args = self.pop_n(n + 1);
+
+		let args = match get_call_outcome(args)? {
+			CallOutcome::Call(args) => args,
+			CallOutcome::Partial(v) => {
+				self.push(v);
+				return Ok(())
+			}
+		};
+
+		if let Value::NativeFunc(nf) = &args[0] {
+			let nf = nf.clone();
+
+			// safety: frame is restored immediately
+			// after function call ends
+			// ~25% performance improvement in
+			// code heavy on native function calls
+			unsafe {
+				let f = std::ptr::read(frame);
+				self.call_stack.push(f);
+			}
+
+			let res = (nf.func)(self, args);
+
+			// safety: frame was referencing invalid memory due to
+			// previous unsafe block, write will fix that
+			unsafe {
+				let f = self.call_stack.pop().expect("no frame to pop");
+				std::ptr::write(frame, f);
+			}
+
+			// make sure we restored the value of frame
+			// before propagating exceptions
+			let res = res?;
+
+			self.push(res);
+		} else if let Value::Function(func) = &args[0] {
+			if self.call_stack.len() + 1 >= self.stack_max {
+				throw!(*SYM_CALL_STACK_OVERFLOW, "call stack overflow")
+			}
+
+			let new_frame = CallFrame::new(func.clone(), args);
+			let old_frame = std::mem::replace(frame, new_frame);
+			self.call_stack.push(old_frame);
+		} else {
+			unreachable!("already verified by calling get_call_type");
+		}
+
+		Ok(())
+	}
 }
 
 #[macro_export]