Superpositions

Author: vkobinski

crates/benda/src/lib.rs

@@ -6,6 +6,7 @@ use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyFunction, PyString, PyTuple};
 use rustpython_parser::{parse, Mode};
 use types::book::Book;
+use types::fan::Fan;
 use types::tree::{Leaf, Node, Tree};
 use types::u24::U24;
 mod benda_ffi;
@@ -142,5 +143,6 @@ fn benda(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<Tree>()?;
     m.add_class::<Node>()?;
     m.add_class::<Leaf>()?;
+    m.add_class::<Fan>()?;
     Ok(())
 }

crates/benda/src/types/book.rs

@@ -5,12 +5,12 @@ use std::vec;
 use bend::fun::{self, Book as BendBook, Name, Rule};
 use bend::imp::{self, Expr, Stmt};
 use indexmap::IndexMap;
-use num_traits::ToPrimitive;
 use pyo3::exceptions::PyException;
 use pyo3::prelude::*;
 use pyo3::types::{PyString, PyTuple};
 use pyo3::PyTypeInfo;
 
+use super::fan::Fan;
 use super::user_adt::{from_term_into_adt, UserAdt};
 use super::{extract_type_raw, BendType};
 use crate::benda_ffi;
@@ -275,6 +275,10 @@ impl Definition {
                     if let Ok(new_term) = term.extract::<Term>() {
                         u_type = Some(new_term.term);
                     }
+                } else if let Ok(term) = arg.downcast::<Fan>() {
+                    if let Ok(new_term) = term.extract::<Fan>() {
+                        u_type = Some(new_term.term);
+                    }
                 } else {
                     let adt = UserAdt::new(arg.clone(), &b);
 

crates/benda/src/types/fan.rs

@@ -0,0 +1,37 @@
+use bend::fun::Term;
+use pyo3::types::{PyString, PyTuple, PyTupleMethods};
+use pyo3::{pyclass, pymethods, Bound, Py, PyAny};
+
+use crate::types::extract_type_raw;
+
+#[pyclass(name = "Fan")]
+#[derive(Clone, Debug, Default)]
+pub struct Fan {
+    pub term: Term,
+}
+
+#[pymethods]
+impl Fan {
+    #[new]
+    #[pyo3(signature = (*args))]
+    fn new(args: Bound<'_, PyTuple>) -> Self {
+        let mut elements: Vec<Term> = vec![];
+        for arg in args.iter() {
+            let new_arg =
+                extract_type_raw(arg.clone()).unwrap().to_bend().unwrap();
+            let u_type = Some(new_arg.clone().to_fun());
+
+            if let Some(u_type) = u_type {
+                elements.push(u_type);
+            }
+        }
+
+        let fan = bend::fun::Term::Fan {
+            fan: bend::fun::FanKind::Tup,
+            tag: bend::fun::Tag::Static,
+            els: elements,
+        };
+
+        Self { term: fan }
+    }
+}

crates/benda/src/types/mod.rs

@@ -12,6 +12,7 @@ use user_adt::UserAdt;
 
 pub mod book;
 pub mod f24;
+pub mod fan;
 pub mod i24;
 pub mod tree;
 pub mod u24;

docs/FFI.md

@@ -98,3 +98,23 @@ sorted_list = book.defs.Sort(my_list).to_adt(book.adts.List)
 ```
 
 This way you can convert the `Term` object into a ADT to use complex data structures in Python.<br>
+
+## Superpositions
+
+Use [superpositions](https://gist.github.com/VictorTaelin/9061306220929f04e7e6980f23ade615) to boost your code performance. Superpositions are a way to call a Bend function multiple times using a `Tuple` of values.<br>
+Example:
+```python
+import benda
+book = benda.load_book_from_file("./examples/sat_solver.bend")
+
+pred = book.defs.pred
+
+x1 = benda.Fan(0,1)
+x2 = benda.Fan(0,1)
+
+result =  pred(x1,x2)
+print("Result:  ", result)
+
+```
+
+Here, Fan represents a superposition of values. This code applies the `pred` function to all the possible values of x1 and x2. The result is a superposition of the results of the function applied to all the possible values of x1 and x2.<br>

examples/sat_solver.bend

@@ -2,4 +2,6 @@ pred = (λx1 λx2
         let nx1=(== x1 0)
         let nx2=(== x2 0)
         let res=(&(&(| x1 x2) (| x1 nx2)) (| nx1 x2))
-        ((x1, x2), res))
+        (res))
+
+main = (pred(0, 1)(0, 1))

examples/sat_solver.py

@@ -5,13 +5,11 @@
 pred = book.defs.pred
 
 def main():
-    x1 = [0,1]
-    x2 = [0,1]
+    x1 = benda.Fan(0,1)
+    x2 = benda.Fan(0,1)
 
-    for i in x1:
-        for x in x2:
-            result =  pred(i, x)
-            print("Result:  ", result)
+    result =  pred(x1,x2)
+    print("Result:  ", result)
 
 
 if __name__ == "__main__":