feat: added proof of concept

Author: raphael-goetz

taurus_poc/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "taurus_poc"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

taurus_poc/build.rs

@@ -0,0 +1,58 @@
+use std::fs::File;
+use std::io::{BufRead, BufReader, Write};
+
+/*
+        Compiled POC 1.
+        This is just writing `rust` as string to a file
+        What can be optimised?
+            - marco to turn macros into a string | import from macro module
+
+        Av. execution time: 2.1µs
+ */
+fn process_input(input_file: &str, output_file: &str) -> std::io::Result<()> {
+    let input = File::open(input_file)?;
+    let reader = BufReader::new(input);
+    let mut output = File::create(output_file)?;
+
+    writeln!(output, "\
+    //This is a generated main file
+macro_rules! add_integers {{
+    ($first:expr, $second:expr) => {{
+        $first + $second
+    }};
+}}
+
+macro_rules! subtract_integers {{
+    ($first:expr, $second:expr) => {{
+        $first - $second
+    }};
+}}
+
+macro_rules! multiply_integers {{
+    ($first:expr, $second:expr) => {{
+        $first * $second
+    }};
+}}
+fn main() {{")?;
+
+    for line in reader.lines() {
+        let line = line?;
+        let parts: Vec<&str> = line.split('|').collect();
+
+        if parts.len() == 3 {
+            match parts[0] {
+                "add" => writeln!(output, "    add_integers!({}, {});", parts[1], parts[2])?,
+                "sub" => writeln!(output, "    subtract_integers!({}, {});", parts[1], parts[2])?,
+                "multiply" => writeln!(output, "    multiply_integers!({}, {});", parts[1], parts[2])?,
+                _ => eprintln!("Unknown operation: {}", parts[0]),
+            }
+        }
+    }
+
+    writeln!(output, "}}")?;
+    Ok(())
+}
+
+fn main() -> std::io::Result<()> {
+    process_input("./poc.txt", "main.rs")
+}

taurus_poc/main.rs

@@ -0,0 +1,24 @@
+//This is a generated main file
+macro_rules! add_integers {
+    ($first:expr, $second:expr) => {
+        $first + $second
+    };
+}
+
+macro_rules! subtract_integers {
+    ($first:expr, $second:expr) => {
+        $first - $second
+    };
+}
+
+macro_rules! multiply_integers {
+    ($first:expr, $second:expr) => {
+        $first * $second
+    };
+}
+fn main() {
+    add_integers!(1, 3);
+    subtract_integers!(2, 4);
+    multiply_integers!(5, 10);
+    add_integers!(3, 100);
+}

taurus_poc/poc.txt

@@ -0,0 +1,4 @@
+add|1|3
+sub|2|4
+multiply|5|10
+add|3|100

taurus_poc/src/main.rs

@@ -0,0 +1,63 @@
+use std::fs::{read_to_string};
+use std::io::BufRead;
+use std::time::Instant;
+
+macro_rules! add_integers {
+    ($first:expr, $second:expr) => {
+        $first+$second
+    };
+}
+
+macro_rules! subtract_integers {
+    ($first:expr, $second:expr) => {
+        $first-$second
+    };
+}
+
+macro_rules! multiply_integers {
+    ($first:expr, $second:expr) => {
+        $first*$second
+    };
+}
+
+/*
+        Interpreted POC 1.
+        This is just interprets incoming flows
+        What can be optimised?
+            - flow till be typed so that no string processing is needed
+            - compromise match statement into map
+            - import macros from shared macro module
+
+        Av. execution time: 627.2µs
+ */
+fn main() {
+    let start = Instant::now();
+
+    for line in read_to_string("taurus_poc/poc.txt").unwrap().lines() {
+
+        let parts: Vec<&str> = line.split('|').collect();
+
+        if parts.len() == 3 {
+            let operator = parts[0];
+            let first: i32 = parts[1].parse().unwrap_or(0);
+            let second: i32 = parts[2].parse().unwrap_or(0);
+
+            let result = match operator {
+                "add" => add_integers!(first, second),
+                "sub" => subtract_integers!(first, second),
+                "multiply" => multiply_integers!(first, second),
+                _ => {
+                    println!("Unsupported operator: {}", operator);
+                    continue;
+                }
+            };
+
+            println!("{} {} {} = {}", operator, first, second, result);
+        } else {
+            println!("Invalid line format");
+        }
+    }
+
+    let duration = start.elapsed();
+    println!("Time elapsed in expensive_function() is: {:?}", duration);
+}