implement interpreter

Author: codeshaunted

internal/interpreter/api.rs

@@ -11,6 +11,7 @@ use i_slint_core::model::{Model, ModelExt, ModelRc};
 use i_slint_core::window::WindowInner;
 use i_slint_core::{PathData, SharedVector};
 use smol_str::SmolStr;
+use std::cell::RefCell;
 use std::collections::HashMap;
 use std::future::Future;
 use std::path::{Path, PathBuf};
@@ -28,6 +29,7 @@ pub use i_slint_core::graphics::{
 use i_slint_core::items::*;
 
 use crate::dynamic_item_tree::{ErasedItemTreeBox, WindowOptions};
+use crate::eval::EvalLocalContext;
 
 /// This enum represents the different public variants of the [`Value`] enum, without
 /// the contained values.
@@ -128,6 +130,8 @@ pub enum Value {
     #[doc(hidden)]
     /// Correspond to the `component-factory` type in .slint
     ComponentFactory(ComponentFactory) = 12,
+    /// A predicate
+    Predicate(Rc<RefCell<dyn FnMut(&mut EvalLocalContext, &Value) -> Value>>) = 13,
 }
 
 impl Value {
@@ -173,6 +177,7 @@ impl PartialEq for Value {
             Value::ComponentFactory(lhs) => {
                 matches!(other, Value::ComponentFactory(rhs) if lhs == rhs)
             }
+            Value::Predicate(p) => matches!(other, Value::Predicate(q) if Rc::ptr_eq(p, q)),
         }
     }
 }
@@ -197,6 +202,7 @@ impl std::fmt::Debug for Value {
             Value::EnumerationValue(n, v) => write!(f, "Value::EnumerationValue({n:?}, {v:?})"),
             Value::LayoutCache(v) => write!(f, "Value::LayoutCache({v:?})"),
             Value::ComponentFactory(factory) => write!(f, "Value::ComponentFactory({factory:?})"),
+            Value::Predicate(_) => write!(f, "Value::Predicate(...)"),
         }
     }
 }
@@ -239,6 +245,7 @@ declare_value_conversion!(PathData => [PathData]);
 declare_value_conversion!(EasingCurve => [i_slint_core::animations::EasingCurve]);
 declare_value_conversion!(LayoutCache => [SharedVector<f32>] );
 declare_value_conversion!(ComponentFactory => [ComponentFactory] );
+declare_value_conversion!(Predicate => [Rc<RefCell<dyn FnMut(&mut EvalLocalContext, &Value) -> Value>>]);
 
 /// Implement From / TryFrom for Value that convert a `struct` to/from `Value::Struct`
 macro_rules! declare_value_struct_conversion {

internal/interpreter/eval.rs

@@ -22,6 +22,7 @@ use i_slint_core as corelib;
 use i_slint_core::input::FocusReason;
 use i_slint_core::items::ItemRc;
 use smol_str::SmolStr;
+use std::cell::RefCell;
 use std::collections::HashMap;
 use std::rc::Rc;
 
@@ -408,7 +409,17 @@ pub fn eval_expression(expression: &Expression, local_context: &mut EvalLocalCon
         }
         Expression::EmptyComponentFactory => Value::ComponentFactory(Default::default()),
         Expression::DebugHook { expression, .. } => eval_expression(expression, local_context),
-        Expression::Predicate { arg_name, expression } => todo!(),
+        Expression::Predicate { arg_name, expression } => {
+            let arg_name = arg_name.clone();
+            let expression = expression.clone();
+            let predicate: Rc<RefCell<dyn Fn(&mut EvalLocalContext<'_, '_>, &Value) -> Value + 'static>> =
+                Rc::new(RefCell::new(move |local_context: &mut EvalLocalContext<'_, '_>, value: &Value| {
+                    local_context.local_variables.insert(arg_name.clone(), value.clone());
+                    eval_expression(&expression, local_context)
+                }));
+
+            Value::Predicate(predicate)
+        },
     }
 }
 
@@ -1369,8 +1380,37 @@ fn call_builtin_function(
                 panic!("internal error: argument to RestartTimer must be an element")
             }
         }
-        BuiltinFunction::ArrayAny => todo!(),
-        BuiltinFunction::ArrayAll => todo!(),
+        BuiltinFunction::ArrayAny => {
+            let model: ModelRc<Value> =
+                eval_expression(&arguments[0], local_context).try_into().unwrap();
+            let predicate: Rc<RefCell<dyn FnMut(&mut EvalLocalContext, &Value) -> Value>> =
+                eval_expression(&arguments[1], local_context).try_into().unwrap();
+            let mut predicate = predicate.borrow_mut();
+
+            for x in model.iter() {
+                if predicate(local_context, &x).try_into().unwrap() {
+                    return Value::Bool(true);
+                }
+            }
+
+            Value::Bool(false)
+        }
+        BuiltinFunction::ArrayAll => {
+            let model: ModelRc<Value> =
+                eval_expression(&arguments[0], local_context).try_into().unwrap();
+            let predicate: Rc<RefCell<dyn FnMut(&mut EvalLocalContext, &Value) -> Value>> =
+                eval_expression(&arguments[1], local_context).try_into().unwrap();
+            let mut predicate = predicate.borrow_mut();
+
+            for x in model.iter() {
+                let result: bool = predicate(local_context, &x).try_into().unwrap();
+                if !result {
+                    return Value::Bool(false);
+                }
+            }
+
+            Value::Bool(true)
+        }
     }
 }