pass1 on PdlResult

Signed-off-by: Nick Mitchell <[email protected]>

Author: starpit

pdl-live-react/src-tauri/src/pdl/interpreter.rs

@@ -21,15 +21,56 @@ use ollama_rs::{
     Ollama,
 };
 
-use serde_json::{from_str, to_string, Map, Value};
+use serde::{Deserialize, Serialize};
+use serde_json::{from_str, to_string, Map, Number, Value};
 use serde_norway::{from_reader, from_str as from_yaml_str};
 
 use crate::pdl::ast::{
-    CallBlock, IfBlock, ListOrString, ModelBlock, ObjectBlock, PdlBlock, PdlParser, PdlUsage,
+    CallBlock, FunctionBlock, IfBlock, ListOrString, ModelBlock, ObjectBlock, PdlBlock, PdlParser, PdlUsage,
     PythonCodeBlock, ReadBlock, RepeatBlock, Role, StringOrBoolean, TextBlock,
 };
 
-type PdlResult = Value;
+#[derive(Serialize, Deserialize, Debug, Clone)]
+struct Closure {
+    scope: Box<Scope>,
+    function: FunctionBlock
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(untagged)]
+enum PdlResult {
+    Closure(Closure),
+    List(Vec<Box<PdlResult>>),
+    Object(HashMap<String, Box<PdlResult>>),
+    Value(Value),
+}
+impl ::std::fmt::Display for PdlResult {
+    // This trait requires `fmt` with this exact signature.
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        let s = match self {
+            PdlResult::Value(Value::String(s)) => s.clone(),
+            PdlResult::Closure(c) => to_string(&c.function).unwrap(),
+            x => x.to_string()
+        };
+        write!(f, "{}", s)
+    }
+}
+impl From<Value> for PdlResult {
+    fn from(v: Value) -> Self {
+        PdlResult::Value(v)
+    }
+}
+impl From<String> for PdlResult {
+    fn from(s: String) -> Self {
+        PdlResult::Value(Value::String(s))
+    }
+}
+impl From<Number> for PdlResult {
+    fn from(n: Number) -> Self {
+        PdlResult::Value(Value::Number(n))
+    }
+}
+
 type Context = Vec<ChatMessage>;
 type Scope = HashMap<String, Value>;
 type PdlError = Box<dyn Error + Send + Sync>;
@@ -83,11 +124,11 @@ impl<'a> Interpreter<'a> {
 
         let (result, messages, trace) = match program {
             PdlBlock::Number(n) => Ok((
-                Value::Number(n.clone()),
+                n.clone().into(),
                 vec![ChatMessage::user(format!("{n}"))],
                 PdlBlock::Number(n.clone()),
             )),
-            PdlBlock::Function(f) => Ok((Value::Null, vec![], PdlBlock::Function(f.clone()))),
+            PdlBlock::Function(f) => Ok((Value::Null.into(), vec![], PdlBlock::Function(f.clone()))),
             PdlBlock::String(s) => self.run_string(s, context).await,
             PdlBlock::Call(block) => self.run_call(block, context).await,
             PdlBlock::If(block) => self.run_if(block, context).await,
@@ -191,7 +232,7 @@ impl<'a> Interpreter<'a> {
         };
         let messages = vec![ChatMessage::user(result.clone())];
 
-        Ok((Value::String(result), messages, trace))
+        Ok((result.into(), messages, trace))
     }
 
     fn path_to(&self, file_path: &String) -> PathBuf {
@@ -228,7 +269,7 @@ impl<'a> Interpreter<'a> {
             }
         }
 
-        Ok(result)
+        Ok(result.into())
     }
 
     /// Run a PdlBlock::Read
@@ -305,7 +346,7 @@ impl<'a> Interpreter<'a> {
             Value::Bool(true) => self.run_quiet(&block.then, context).await,
             Value::Bool(false) => match &block.else_ {
                 Some(else_block) => self.run_quiet(&else_block, context).await,
-                None => Ok((Value::Null, vec![], PdlBlock::If(block.clone()))),
+                None => Ok((Value::Null.into(), vec![], PdlBlock::If(block.clone()))),
             },
             x => Err(Box::from(format!(
                 "if block condition evaluated to non-boolean value: {:?}",
@@ -392,7 +433,7 @@ impl<'a> Interpreter<'a> {
                         .unwrap();
                     let messages = vec![ChatMessage::user(result_string.as_str().to_string())];
                     let trace = PdlBlock::PythonCode(block.clone());
-                    Ok((Value::String(messages[0].content.clone()), messages, trace))
+                    Ok((messages[0].content.clone().into(), messages, trace))
                 }
                 Err(_) => Err(Box::from(
                     "Python code block failed to assign a 'result' variable",
@@ -507,13 +548,13 @@ impl<'a> Interpreter<'a> {
                     let mut message = res.message.clone();
                     message.content = response_string;
                     Ok((
-                        Value::String(message.content.clone()),
+                        message.content.clone().into(),
                         vec![message],
                         PdlBlock::Model(trace),
                     ))
                 } else {
                     // nothing came out of the model
-                    Ok((Value::Null, vec![], PdlBlock::Model(trace)))
+                    Ok((Value::Null.into(), vec![], PdlBlock::Model(trace)))
                 }
                 // dbg!(history);
             }
@@ -523,22 +564,23 @@ impl<'a> Interpreter<'a> {
 
     async fn run_object(&mut self, block: &ObjectBlock, context: Context) -> Interpretation {
         let mut messages = vec![];
-        let mut result_map = Map::new();
+        let mut result_map = HashMap::new();
         let mut trace_map = HashMap::new();
         let mut iter = block.object.iter();
         while let Some((k, v)) = iter.next() {
             let (this_result, this_messages, this_trace) =
                 self.run_quiet(v, context.clone()).await?;
             messages.extend(this_messages);
-            result_map.insert(k.clone(), this_result);
+            result_map.insert(k.clone(), Box::from(this_result))
+                ;
             trace_map.insert(k.clone(), this_trace);
         }
 
         if self.debug {
             eprintln!("Object {:?}", result_map);
         }
         Ok((
-            Value::Object(result_map),
+            PdlResult::Object(result_map),
             messages,
             PdlBlock::Object(ObjectBlock { object: trace_map }),
         ))
@@ -574,15 +616,15 @@ impl<'a> Interpreter<'a> {
                     .collect();
                 self.extend_scope_with_map(scope);
                 let (result, ms, t) = self.run_quiet(&block.repeat, context.clone()).await?;
-                results.push(result);
+                results.push(Box::from(result));
                 messages.extend(ms);
                 trace.push(t);
                 self.scope.pop();
             }
         }
 
         Ok((
-            Value::Array(results),
+            PdlResult::List(results),
             messages,
             PdlBlock::Repeat(block.clone()),
         ))
@@ -679,10 +721,7 @@ impl<'a> Interpreter<'a> {
 
         let result_string = output_results
             .into_iter()
-            .map(|m| match m {
-                Value::String(s) => s,
-                x => x.to_string(),
-            })
+            .map(|m| m.to_string())
             .collect::<Vec<_>>()
             .join("\n");