1use crate::{
2 RiddleError,
3 env::{BoolExpr, CommonEnv, Env, Slot, Var, get_var_by_path, to_cnf},
4 scope::{Scope, Type, get_type_by_path, is_assignable_from},
5};
6use std::{
7 collections::{HashMap, VecDeque},
8 fmt,
9 rc::Rc,
10};
11
12pub struct ProblemDef {
13 pub functions: Vec<FunctionDef>,
14 pub predicates: Vec<PredicateDef>,
15 pub classes: Vec<ClassDef>,
16 pub statements: Vec<Statement>,
17}
18
19pub type FieldDef = (Vec<String>, Vec<(String, Option<Expr>)>); pub struct ClassDef {
22 pub name: String,
23 pub parents: Vec<Vec<String>>,
24 pub fields: Vec<FieldDef>,
25 pub constructors: Vec<ConstructorDef>,
26 pub functions: Vec<FunctionDef>,
27 pub predicates: Vec<PredicateDef>,
28 pub classes: Vec<ClassDef>,
29}
30
31pub struct ConstructorDef {
32 pub args: Vec<(Vec<String>, String)>,
33 pub init: Vec<(Vec<String>, Vec<Expr>)>,
34 pub statements: Vec<Statement>,
35}
36
37pub struct FunctionDef {
38 pub return_type: Option<Vec<String>>,
39 pub name: String,
40 pub args: Vec<(Vec<String>, String)>,
41 pub statements: Vec<Statement>,
42}
43
44pub struct PredicateDef {
45 pub name: String,
46 pub args: Vec<(Vec<String>, String)>,
47 pub parents: Vec<Vec<String>>,
48 pub statements: Vec<Statement>,
49}
50
51#[derive(Debug, PartialEq, Clone)]
52pub enum Statement {
53 Expr(Expr),
54 LocalField { field_type: Vec<String>, fields: Vec<(String, Option<Expr>)> },
55 Assign { name: Vec<String>, value: Expr },
56 ForAll { var_type: Vec<String>, var_name: String, statements: Vec<Statement> },
57 Disjunction { disjuncts: Vec<(Vec<Statement>, Expr)> },
58 Formula { is_fact: bool, name: String, tau: Vec<String>, predicate_name: String, args: Vec<(String, Expr)> },
59 Return { value: Expr },
60}
61
62impl fmt::Display for Statement {
63 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
64 match self {
65 Statement::Expr(e) => write!(f, "{};", e),
66 Statement::LocalField { field_type, fields } => write!(f, "{} {};", field_type.join("."), fields.iter().map(|(n, v)| format!("{}{}", n, v.as_ref().map(|v| format!(" = {}", v)).unwrap_or_default())).collect::<Vec<_>>().join(", ")),
67 Statement::Assign { name, value } => write!(f, "{} = {};", name.join("."), value),
68 Statement::ForAll { var_type, var_name, statements } => write!(f, "for {} {} {{\n{}\n}}", var_type.join("."), var_name, statements.iter().map(|s| format!(" {}", s)).collect::<Vec<_>>().join("\n")),
69 Statement::Disjunction { disjuncts } => write!(f, "{{\n{}\n}}", disjuncts.iter().map(|(s, e)| format!(" {{\n{}\n }}: {}", s.iter().map(|s| format!(" {}", s)).collect::<Vec<_>>().join("\n"), e)).collect::<Vec<_>>().join(" or ")),
70 Statement::Formula { is_fact, name, tau, predicate_name, args } => write!(f, "{} {} = new {}{}({});", if *is_fact { "fact" } else { "formula" }, name, if tau.is_empty() { String::new() } else { tau.join(".") + "." }, predicate_name, args.iter().map(|(n, e)| format!("{}: {}", n, e)).collect::<Vec<_>>().join(", ")),
71 Statement::Return { value } => write!(f, "return {};", value),
72 }
73 }
74}
75
76#[derive(Debug, PartialEq, Clone)]
77pub enum Expr {
78 Bool(bool),
79 Int(i64),
80 Real(i64, i64),
81 String(String),
82 QualifiedId { ids: Vec<String> },
83 Sum { terms: Vec<Expr> },
84 Opposite { term: Box<Expr> },
85 Not { term: Box<Expr> },
86 Mul { factors: Vec<Expr> },
87 Div { left: Box<Expr>, right: Box<Expr> },
88 Function { name: Vec<String>, args: Vec<Expr> },
89 Eq { left: Box<Expr>, right: Box<Expr> },
90 Neq { left: Box<Expr>, right: Box<Expr> },
91 Lt { left: Box<Expr>, right: Box<Expr> },
92 Leq { left: Box<Expr>, right: Box<Expr> },
93 Gt { left: Box<Expr>, right: Box<Expr> },
94 Geq { left: Box<Expr>, right: Box<Expr> },
95 Or { terms: Vec<Expr> },
96 And { terms: Vec<Expr> },
97 NewObject { class_name: Vec<String>, args: Vec<Expr> },
98}
99
100impl fmt::Display for Expr {
101 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
102 match self {
103 Expr::Bool(b) => write!(f, "{}", b),
104 Expr::Int(i) => write!(f, "{}", i),
105 Expr::Real(n, d) => write!(f, "{}/{}", n, d),
106 Expr::String(s) => write!(f, "\"{}\"", s),
107 Expr::QualifiedId { ids } => write!(f, "{}", ids.join(".")),
108 Expr::Sum { terms } => write!(f, "({})", terms.iter().map(|t| format!("{}", t)).collect::<Vec<_>>().join(" + ")),
109 Expr::Opposite { term } => write!(f, "-({})", term),
110 Expr::Not { term } => write!(f, "!({})", term),
111 Expr::Mul { factors } => write!(f, "({})", factors.iter().map(|t| format!("{}", t)).collect::<Vec<_>>().join(" * ")),
112 Expr::Div { left, right } => write!(f, "({} / {})", left, right),
113 Expr::Function { name, args } => write!(f, "{}({})", name.join("."), args.iter().map(|a| format!("{}", a)).collect::<Vec<_>>().join(", ")),
114 Expr::Eq { left, right } => write!(f, "({} == {})", left, right),
115 Expr::Neq { left, right } => write!(f, "({} != {})", left, right),
116 Expr::Lt { left, right } => write!(f, "({} < {})", left, right),
117 Expr::Leq { left, right } => write!(f, "({} <= {})", left, right),
118 Expr::Gt { left, right } => write!(f, "({} > {})", left, right),
119 Expr::Geq { left, right } => write!(f, "({} >= {})", left, right),
120 Expr::Or { terms } => write!(f, "({})", terms.iter().map(|t| format!("{}", t)).collect::<Vec<_>>().join(" || ")),
121 Expr::And { terms } => write!(f, "({})", terms.iter().map(|t| format!("{}", t)).collect::<Vec<_>>().join(" && ")),
122 Expr::NewObject { class_name, args } => write!(f, "new {}({})", class_name.join("."), args.iter().map(|a| format!("{}", a)).collect::<Vec<_>>().join(", ")),
123 }
124 }
125}
126
127pub struct Disjunction {
128 pub scp: Rc<dyn Scope>,
129 pub env: Rc<dyn Env>,
130 pub disjuncts: Vec<(Vec<Statement>, Expr)>,
131}
132
133pub fn execute(scp: &Rc<dyn Scope>, env: Rc<dyn Env>, stmt: &Statement) -> Result<(), RiddleError> {
134 match stmt {
135 Statement::Expr(expr) => {
136 let expr = evaluate(scp.as_ref(), env, expr)?;
137 if let Slot::Primitive(var) = expr.clone()
138 && let Ok(bool_expr) = var.as_any().downcast::<BoolExpr>()
139 {
140 scp.core().assert(to_cnf(bool_expr));
141 Ok(())
142 } else {
143 Err(RiddleError::RuntimeError(format!("Expected boolean expression, got {}", expr)))
144 }
145 }
146 Statement::LocalField { field_type, fields } => {
147 let fld_tp = get_type_by_path(scp.as_ref(), field_type)?;
148 for (name, default) in fields {
149 if let Some(expr) = default {
150 let value = evaluate(scp.as_ref(), env.clone(), expr)?;
151 match &value {
152 Slot::Primitive(var) => {
153 if !is_assignable_from(&fld_tp, &var.var_type()) {
154 return Err(RiddleError::TypeError(format!("Default value for field '{}' is not assignable to field type '{}'", name, field_type.join("."))));
155 }
156 }
157 Slot::ObjectRef(obj_id) => {
158 let obj = scp.core().get_object(*obj_id).ok_or_else(|| RiddleError::NotFound(format!("Object {} not found", *obj_id)))?;
159 let obj_type: Rc<dyn Type> = obj.class();
160 if !is_assignable_from(&fld_tp, &obj_type) {
161 return Err(RiddleError::TypeError(format!("Default value for field '{}' is not assignable to field type '{}'", name, field_type.join("."))));
162 }
163 }
164 Slot::AtomRef(atom_id) => {
165 let atom = scp.core().get_atom(*atom_id).ok_or_else(|| RiddleError::NotFound(format!("Atom {} not found", *atom_id)))?;
166 let atom_type: Rc<dyn Type> = atom.predicate();
167 if !is_assignable_from(&fld_tp, &atom_type) {
168 return Err(RiddleError::TypeError(format!("Default value for field '{}' is not assignable to field type '{}'", name, field_type.join("."))));
169 }
170 }
171 }
172 env.set(name.clone(), value);
173 } else if let Some(class) = fld_tp.clone().as_class() {
174 let instances = class.instances();
175 if instances.is_empty() {
176 return Err(RiddleError::RuntimeError(format!("No instances found for field '{}' of type '{}'", name, class.full_name())));
177 } else if instances.len() == 1 {
178 env.set(name.clone(), Slot::ObjectRef(instances[0]));
179 } else {
180 env.set(name.clone(), scp.core().new_var(class, instances.as_slice())?);
181 }
182 } else {
183 env.set(name.clone(), fld_tp.clone().new_instance());
184 }
185 }
186 Ok(())
187 }
188 Statement::Assign { name, value } => {
189 let value = evaluate(scp.as_ref(), env.clone(), value)?;
190 if name.len() == 1 {
191 env.set(name[0].clone(), value);
192 Ok(())
193 } else {
194 let (last, rest) = name.split_last().ok_or_else(|| RiddleError::RuntimeError("Empty assignment path".into()))?;
195 let var = get_var_by_path(scp.core().as_ref(), env.as_ref(), rest)?;
196 match &var {
197 Slot::Primitive(_) => Err(RiddleError::NotAnEnvironment(format!("Variable '{}' in assignment path is a primitive variable, cannot assign to '{}'", rest.join("."), last))),
198 Slot::ObjectRef(obj_id) => {
199 let obj = scp.core().get_object(*obj_id).ok_or_else(|| RiddleError::NotFound(format!("Object {} not found", *obj_id)))?;
200 obj.as_env().ok_or_else(|| RiddleError::NotAnEnvironment(format!("Object {} does not have an environment", *obj_id)))?.set(last.to_string(), value);
201 Ok(())
202 }
203 Slot::AtomRef(atom_id) => {
204 let atom = scp.core().get_atom(*atom_id).ok_or_else(|| RiddleError::NotFound(format!("Atom {} not found", *atom_id)))?;
205 atom.as_env().ok_or_else(|| RiddleError::NotAnEnvironment(format!("Atom {} does not have an environment", *atom_id)))?.set(last.to_string(), value);
206 Ok(())
207 }
208 }
209 }
210 }
211 Statement::ForAll { var_type, var_name, statements } => {
212 let class = get_type_by_path(scp.as_ref(), var_type)?.as_class().ok_or_else(|| RiddleError::NotAClass(var_type.join(".")))?;
213 for instance in class.instances() {
214 let loop_env = Rc::new(CommonEnv::new(Some(env.clone())));
215 loop_env.set(var_name.clone(), Slot::ObjectRef(instance));
216 for stmt in statements {
217 execute(scp, loop_env.clone(), stmt)?;
218 }
219 }
220 Ok(())
221 }
222 Statement::Disjunction { disjuncts } => {
223 let disjunction = Disjunction { scp: scp.clone(), env: env.clone(), disjuncts: disjuncts.clone() };
224 scp.core().new_disjunction(disjunction);
225 Ok(())
226 }
227 Statement::Formula { is_fact, name, tau, predicate_name, args } => {
228 let tau = if tau.is_empty() { None } else { Some(get_var_by_path(scp.core().as_ref(), env.as_ref(), tau)?) };
229 let predicate = if let Some(tau) = tau.as_ref() {
230 let tau = match tau {
231 Slot::Primitive(var) => Err(RiddleError::NotAClass(format!("Tau variable is a primitive variable of type '{}', expected a class", var.var_type().full_name()))),
232 Slot::ObjectRef(obj_id) => scp.core().get_object(*obj_id).ok_or_else(|| RiddleError::NotFound(format!("Object {} not found", *obj_id))),
233 Slot::AtomRef(atom_id) => Err(RiddleError::NotAClass(format!("Tau variable is an atom {}, expected a class", *atom_id))),
234 }?;
235 tau.var_type().as_class().ok_or_else(|| RiddleError::NotAClass(format!("Type '{}' in tau path", tau.var_type().full_name())))?.get_predicate(predicate_name).ok_or_else(|| RiddleError::NotFound(format!("Predicate '{}' in class '{}'", predicate_name, tau.var_type().full_name())))?
236 } else {
237 scp.get_predicate(predicate_name).ok_or_else(|| RiddleError::NotFound(format!("Predicate '{}'", predicate_name)))?
238 };
239 let mut args: HashMap<String, Slot> = args
240 .iter()
241 .map(|(n, e)| {
242 let val = evaluate(scp.as_ref(), env.clone(), e)?;
243 Ok((n.clone(), val))
244 })
245 .collect::<Result<_, _>>()?;
246 if let Some(tau) = tau {
247 args.insert("tau".to_string(), tau);
248 }
249 let mut pred_hierarchy = VecDeque::from(vec![predicate.clone()]);
250 while let Some(pred) = pred_hierarchy.pop_front() {
251 for (arg_type, name) in pred.args() {
252 if !args.contains_key(name) {
253 let arg_tp = get_type_by_path(scp.as_ref(), arg_type)?;
254 if let Some(class) = arg_tp.clone().as_class() {
255 let instances = class.instances();
256 if instances.is_empty() {
257 return Err(RiddleError::RuntimeError(format!("No instances found for argument '{}' of type '{}'", name, class.full_name())));
258 } else if instances.len() == 1 {
259 args.insert(name.clone(), Slot::ObjectRef(instances[0]));
260 } else {
261 args.insert(name.clone(), scp.core().new_var(class, instances.as_slice())?);
262 }
263 } else {
264 args.insert(name.clone(), arg_tp.new_instance());
265 }
266 }
267 }
268 for parent_path in pred.parents() {
269 let (predicate_name, class_path) = parent_path.split_last().ok_or_else(|| RiddleError::RuntimeError("Empty parent predicate path".into()))?;
270 let parent_predicate = if class_path.is_empty() {
271 scp.get_predicate(predicate_name).ok_or_else(|| RiddleError::NotFound(format!("Predicate '{}' in parent path", predicate_name)))?
272 } else {
273 let class = get_type_by_path(scp.as_ref(), class_path)?.as_class().ok_or_else(|| RiddleError::NotAClass(format!("Type '{}' in parent path", class_path.join("."))))?;
274 class.get_predicate(predicate_name).ok_or_else(|| RiddleError::NotFound(format!("Predicate '{}' in class '{}'", predicate_name, class.full_name())))?
275 };
276 pred_hierarchy.push_back(parent_predicate);
277 }
278 }
279 let atom = scp.core().new_atom(predicate, *is_fact, args);
280 env.set(name.clone(), Slot::AtomRef(atom));
281 Ok(())
282 }
283 Statement::Return { value } => {
284 let ret = evaluate(scp.as_ref(), env.clone(), value)?;
285 env.set("__return".to_string(), ret);
286 Ok(())
287 }
288 }
289}
290
291pub fn evaluate(scp: &dyn Scope, env: Rc<dyn Env>, expr: &Expr) -> Result<Slot, RiddleError> {
292 match expr {
293 Expr::Bool(bool) => Ok(scp.core().new_bool(*bool)),
294 Expr::Int(int) => Ok(scp.core().new_int(*int)),
295 Expr::Real(num, den) => Ok(scp.core().new_real(*num, *den)),
296 Expr::String(string) => Ok(scp.core().new_string(string)),
297 Expr::QualifiedId { ids } => get_var_by_path(scp.core().as_ref(), env.as_ref(), ids),
298 Expr::Sum { terms } => {
299 let evaluated_terms: Vec<Slot> = terms.iter().map(|t| evaluate(scp, env.clone(), t)).collect::<Result<_, _>>()?;
300 Ok(scp.core().sum(&evaluated_terms)?)
301 }
302 Expr::Opposite { term } => {
303 let evaluated_term = evaluate(scp, env, term)?;
304 Ok(scp.core().opposite(evaluated_term)?)
305 }
306 Expr::Not { term } => {
307 let evaluated_term = evaluate(scp, env, term)?;
308 match &evaluated_term {
309 Slot::Primitive(var) => {
310 if let Ok(bool_expr) = var.clone().as_any().downcast::<BoolExpr>() {
311 Ok(Slot::Primitive(Rc::new(BoolExpr::Not { var_type: Rc::downgrade(&scp.core().bool_type()), term: bool_expr })))
312 } else {
313 Err(RiddleError::RuntimeError(format!("Expected boolean expression, got {}", evaluated_term)))
314 }
315 }
316 _ => Err(RiddleError::RuntimeError(format!("Expected a primitive variable for negation, got {}", evaluated_term))),
317 }
318 }
319 Expr::Mul { factors } => {
320 let evaluated_factors: Vec<Slot> = factors.iter().map(|f| evaluate(scp, env.clone(), f)).collect::<Result<_, _>>()?;
321 Ok(scp.core().mul(&evaluated_factors)?)
322 }
323 Expr::Div { left, right } => {
324 let evaluated_left = evaluate(scp, env.clone(), left)?;
325 let evaluated_right = evaluate(scp, env, right)?;
326 Ok(scp.core().div(evaluated_left, evaluated_right)?)
327 }
328 Expr::Function { name, args } => {
329 let args = args.iter().map(|a| evaluate(scp, env.clone(), a)).collect::<Result<Vec<_>, _>>()?;
330 let arg_types = args
331 .iter()
332 .map(|a| match a {
333 Slot::Primitive(var) => Ok(var.var_type()),
334 Slot::ObjectRef(obj_id) => Ok(scp.core().get_object(*obj_id).ok_or_else(|| RiddleError::NotFound(format!("Object {} not found", *obj_id)))?.var_type()),
335 Slot::AtomRef(atom_id) => Ok(scp.core().get_atom(*atom_id).ok_or_else(|| RiddleError::NotFound(format!("Atom {} not found", *atom_id)))?.var_type()),
336 })
337 .collect::<Result<Vec<_>, _>>()?;
338 let (last, rest) = name.split_last().ok_or_else(|| RiddleError::RuntimeError("Empty function path".into()))?;
339 if rest.is_empty() {
340 if let Some(function) = scp.get_function(last, &arg_types) {
341 let out = function.call(env, args)?;
342 out.ok_or_else(|| RiddleError::RuntimeError(format!("Function '{}' with argument types ({}) did not return a value", last, arg_types.iter().map(|t| t.full_name()).collect::<Vec<_>>().join(", "))))
343 } else {
344 Err(RiddleError::NotFound(format!("Function '{}' with argument types ({}) not found", last, arg_types.iter().map(|t| t.full_name()).collect::<Vec<_>>().join(", "))))
345 }
346 } else {
347 let var = get_var_by_path(scp.core().as_ref(), env.as_ref(), rest)?;
348 match &var {
349 Slot::Primitive(_) => Err(RiddleError::NotAClass(format!("Variable '{}' in function path is a primitive variable, expected an object or atom for function call", rest.join(".")))),
350 Slot::ObjectRef(obj_id) => {
351 let obj = scp.core().get_object(*obj_id).ok_or_else(|| RiddleError::NotFound(format!("Object {} not found", *obj_id)))?;
352 if let Some(function) = obj.class().get_function(last, &arg_types) {
353 let out = function.call(obj.as_env().ok_or_else(|| RiddleError::NotAnEnvironment(format!("Object {} does not have an environment", *obj_id)))?, args)?;
354 out.ok_or_else(|| RiddleError::RuntimeError(format!("Function '{}' with argument types ({}) did not return a value", last, arg_types.iter().map(|t| t.full_name()).collect::<Vec<_>>().join(", "))))
355 } else {
356 Err(RiddleError::NotFound(format!("Function '{}' with argument types ({}) not found in class '{}'", last, arg_types.iter().map(|t| t.full_name()).collect::<Vec<_>>().join(", "), obj.class().full_name())))
357 }
358 }
359 Slot::AtomRef(atom_id) => Err(RiddleError::NotAClass(format!("Variable '{}' in function path is an atom {}, expected an object for function call", rest.join("."), *atom_id))),
360 }
361 }
362 }
363 Expr::Eq { left, right } => {
364 let evaluated_left = evaluate(scp, env.clone(), left)?;
365 let evaluated_right = evaluate(scp, env, right)?;
366 Ok(Slot::Primitive(Rc::new(BoolExpr::Eq {
367 var_type: Rc::downgrade(&scp.core().bool_type()),
368 left: evaluated_left,
369 right: evaluated_right,
370 })))
371 }
372 Expr::Neq { left, right } => {
373 let evaluated_left = evaluate(scp, env.clone(), left)?;
374 let evaluated_right = evaluate(scp, env, right)?;
375 Ok(Slot::Primitive(Rc::new(BoolExpr::Not {
376 var_type: Rc::downgrade(&scp.core().bool_type()),
377 term: Rc::new(BoolExpr::Eq {
378 var_type: Rc::downgrade(&scp.core().bool_type()),
379 left: evaluated_left,
380 right: evaluated_right,
381 }),
382 })))
383 }
384 Expr::Lt { left, right } => {
385 let evaluated_left = evaluate(scp, env.clone(), left)?;
386 let evaluated_right = evaluate(scp, env, right)?;
387 Ok(Slot::Primitive(Rc::new(BoolExpr::Lt {
388 var_type: Rc::downgrade(&scp.core().bool_type()),
389 left: evaluated_left,
390 right: evaluated_right,
391 })))
392 }
393 Expr::Leq { left, right } => {
394 let evaluated_left = evaluate(scp, env.clone(), left)?;
395 let evaluated_right = evaluate(scp, env, right)?;
396 Ok(Slot::Primitive(Rc::new(BoolExpr::Leq {
397 var_type: Rc::downgrade(&scp.core().bool_type()),
398 left: evaluated_left,
399 right: evaluated_right,
400 })))
401 }
402 Expr::Geq { left, right } => {
403 let evaluated_left = evaluate(scp, env.clone(), left)?;
404 let evaluated_right = evaluate(scp, env, right)?;
405 Ok(Slot::Primitive(Rc::new(BoolExpr::Leq {
406 var_type: Rc::downgrade(&scp.core().bool_type()),
407 left: evaluated_right,
408 right: evaluated_left,
409 })))
410 }
411 Expr::Gt { left, right } => {
412 let evaluated_left = evaluate(scp, env.clone(), left)?;
413 let evaluated_right = evaluate(scp, env, right)?;
414 Ok(Slot::Primitive(Rc::new(BoolExpr::Lt {
415 var_type: Rc::downgrade(&scp.core().bool_type()),
416 left: evaluated_right,
417 right: evaluated_left,
418 })))
419 }
420 Expr::Or { terms } => {
421 let evaluated_terms: Vec<Rc<BoolExpr>> = terms
422 .iter()
423 .map(|t| match evaluate(scp, env.clone(), t)? {
424 Slot::Primitive(var) => {
425 if let Ok(bool_expr) = var.as_any().downcast::<BoolExpr>() {
426 Ok(bool_expr)
427 } else {
428 Err(RiddleError::RuntimeError("Expected boolean expression in 'or' term".to_string()))
429 }
430 }
431 _ => Err(RiddleError::RuntimeError("Expected boolean expression in 'or' term".to_string())),
432 })
433 .collect::<Result<_, _>>()?;
434 Ok(Slot::Primitive(Rc::new(BoolExpr::Or { var_type: Rc::downgrade(&scp.core().bool_type()), terms: evaluated_terms })))
435 }
436 Expr::And { terms } => {
437 let evaluated_terms: Vec<Rc<BoolExpr>> = terms
438 .iter()
439 .map(|t| match evaluate(scp, env.clone(), t)? {
440 Slot::Primitive(var) => {
441 if let Ok(bool_expr) = var.as_any().downcast::<BoolExpr>() {
442 Ok(bool_expr)
443 } else {
444 Err(RiddleError::RuntimeError("Expected boolean expression in 'and' term".to_string()))
445 }
446 }
447 _ => Err(RiddleError::RuntimeError("Expected boolean expression in 'and' term".to_string())),
448 })
449 .collect::<Result<_, _>>()?;
450 Ok(Slot::Primitive(Rc::new(BoolExpr::And { var_type: Rc::downgrade(&scp.core().bool_type()), terms: evaluated_terms })))
451 }
452 Expr::NewObject { class_name, args } => {
453 let class = get_type_by_path(scp, class_name)?.as_class().ok_or_else(|| RiddleError::NotAClass(class_name.join(".")))?;
454 let args = args.iter().map(|a| evaluate(scp, env.clone(), a)).collect::<Result<Vec<_>, _>>()?;
455 let arg_types = args
456 .iter()
457 .map(|a| match a {
458 Slot::Primitive(var) => Ok(var.var_type()),
459 Slot::ObjectRef(obj_id) => Ok(scp.core().get_object(*obj_id).ok_or_else(|| RiddleError::NotFound(format!("Object {} not found", *obj_id)))?.var_type()),
460 Slot::AtomRef(atom_id) => Ok(scp.core().get_atom(*atom_id).ok_or_else(|| RiddleError::NotFound(format!("Atom {} not found", *atom_id)))?.var_type()),
461 })
462 .collect::<Result<Vec<_>, _>>()?;
463 let constructor = class.constructor(&arg_types).ok_or_else(|| RiddleError::NotFound(format!("Constructor for class '{}' with argument types ({}) not found", class.full_name(), arg_types.iter().map(|t| t.full_name()).collect::<Vec<_>>().join(", "))))?;
464 let object = class.new_instance();
465 let object = match object {
466 Slot::ObjectRef(obj_id) => Ok(obj_id),
467 _ => Err(RiddleError::RuntimeError("Constructor did not return an object reference".to_string())),
468 }?;
469 constructor.call(object, args)?;
470 Ok(Slot::ObjectRef(object))
471 }
472 }
473}