Add pared feature which integrates the pared dependency so that you can

Use Arc projection refs to documents avoiding heavy clones when using a dynamic resolver.

Signed-off-by: Hiram Chirino <[email protected]>

interpreter/Cargo.toml

@@ -8,6 +8,9 @@ edition = "2018"
 license = "MIT"
 categories = ["interpreter", "cel"]
 
+[features]
+pared = ["dep:pared"]
+
 [dependencies]
 cel-parser = { path = "../parser", version = "0.6.0" }
 thiserror = "1.0.40"
@@ -16,6 +19,7 @@ nom = "7.1.3"
 paste = "1.0.14"
 serde = "1.0.196"
 regex = "1.10.5"
+pared = {  version="0.3.0",  optional = true }
 
 [dev-dependencies]
 criterion = { version = "0.5.1", features = ["html_reports"] }

interpreter/src/functions.rs

@@ -547,7 +547,6 @@ mod tests {
     use std::sync::Arc;
 
     use crate::context::Context;
-    use crate::objects::{DynamicCollection, MemberResolver, ResolvedMember};
     use crate::testing::test_script;
     use crate::Value;
     use std::collections::HashMap;
@@ -789,18 +788,21 @@ mod tests {
         assert_eq!(test_script("hello == 'world'", Some(ctx)), Ok(true.into()));
     }
 
+    #[cfg(feature = "pared")]
     #[test]
     fn test_deep_dynamic_resolver() {
+        use crate::objects::{MemberResolver, ParcDynamicCollection, ResolvedMember};
+        use pared::sync::Parc;
+
         #[derive(Clone)]
         struct Species {
             name: String,
             language: Option<String>,
             homeworld: Option<String>,
         }
 
-        impl DynamicCollection for Species {
-            fn resolver(&self) -> MemberResolver {
-                let receiver = self.clone();
+        impl ParcDynamicCollection<Species> for Species {
+            fn resolver(receiver: Parc<Species>) -> MemberResolver {
                 MemberResolver::new(move |name| match name {
                     ResolvedMember::Attribute(name) => match name.as_str() {
                         "name" => Some(receiver.name.clone().into()),
@@ -826,17 +828,16 @@ mod tests {
             species: Species,
         }
 
-        impl DynamicCollection for Character {
-            fn resolver(&self) -> MemberResolver {
-                let receiver = self.clone();
+        impl ParcDynamicCollection<Character> for Character {
+            fn resolver(receiver: Parc<Character>) -> MemberResolver {
                 MemberResolver::new(move |member| match member {
                     ResolvedMember::Attribute(name) => match name.as_str() {
                         "name" => Some(receiver.name.clone().into()),
                         "gender" => match receiver.gender.clone() {
                             Some(v) => Some(v.clone().into()),
                             None => Some(Value::Null),
                         },
-                        "species" => Some(receiver.species.clone().into()),
+                        "species" => Some(receiver.project(|receiver| &receiver.species).into()),
                         _ => None,
                     },
                     _ => None,
@@ -851,9 +852,8 @@ mod tests {
             characters: Vec<Character>,
         }
 
-        impl DynamicCollection for Film {
-            fn resolver(&self) -> MemberResolver {
-                let receiver = self.clone();
+        impl ParcDynamicCollection<Film> for Film {
+            fn resolver(receiver: Parc<Film>) -> MemberResolver {
                 MemberResolver::new(move |member| {
                     let receiver = receiver.clone();
                     match member {
@@ -865,9 +865,11 @@ mod tests {
                                     let receiver = receiver.clone();
                                     match member {
                                         ResolvedMember::Index(Value::Int(idx)) => receiver
-                                            .characters
-                                            .get(idx as usize)
-                                            .map(|v| v.clone().into()),
+                                            .try_project(|receiver| {
+                                                receiver.characters.get(idx as usize).ok_or(())
+                                            })
+                                            .ok()
+                                            .map(|x| x.into()),
                                         _ => None,
                                     }
                                 },
@@ -880,7 +882,7 @@ mod tests {
             }
         }
 
-        let doc = Film {
+        let doc = Parc::new(Film {
             director: "George Lucas".to_string(),
             title: "A New Hope".to_string(),
             characters: vec![
@@ -912,7 +914,7 @@ mod tests {
                     },
                 },
             ],
-        };
+        });
 
         let mut ctx = Context::default();
         ctx.set_dynamic_resolver(move |name| match name {

interpreter/src/objects.rs

@@ -707,20 +707,39 @@ pub trait DynamicCollection {
     fn resolver(&self) -> MemberResolver;
 }
 
-impl <T> From<T> for Value
-where T: DynamicCollection {
+impl<T> From<T> for Value
+where
+    T: DynamicCollection,
+{
     fn from(item: T) -> Self {
         Value::DynamicCollection(item.resolver())
     }
 }
 
-impl <T> From<Arc<T>> for Value
-where T: DynamicCollection {
+impl<T> From<Arc<T>> for Value
+where
+    T: DynamicCollection,
+{
     fn from(item: Arc<T>) -> Self {
         Value::DynamicCollection(item.resolver())
     }
 }
 
+#[cfg(feature = "pared")]
+pub trait ParcDynamicCollection<T> {
+    fn resolver(item: pared::sync::Parc<T>) -> MemberResolver;
+}
+
+#[cfg(feature = "pared")]
+impl<T> From<pared::sync::Parc<T>> for Value
+where
+    T: ParcDynamicCollection<T>,
+{
+    fn from(item: pared::sync::Parc<T>) -> Self {
+        Value::DynamicCollection(T::resolver(item))
+    }
+}
+
 impl ops::Add<Value> for Value {
     type Output = Value;