feat(ir): BROKEN: replace Rpl with GraphIr

This commit will be removed in a later force-push.

Cargo.lock

@@ -8,6 +8,20 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
 
+[[package]]
+name = "ahash"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77c3a9648d43b9cd48db467b3f87fdd6e146bcc88ab0180006cef2179fe11d01"
+dependencies = [
+ "cfg-if",
+ "getrandom",
+ "once_cell",
+ "serde",
+ "version_check",
+ "zerocopy",
+]
+
 [[package]]
 name = "anstream"
 version = "0.6.5"
@@ -217,7 +231,7 @@ version = "0.1.0"
 dependencies = [
  "clap",
  "image",
- "rpl",
+ "ir",
 ]
 
 [[package]]
@@ -264,6 +278,17 @@ dependencies = [
  "spin",
 ]
 
+[[package]]
+name = "getrandom"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "190092ea657667030ac6a35e305e62fc4dd69fd98ac98631e5d3a2b1575a12b5"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
 [[package]]
 name = "gif"
 version = "0.12.0"
@@ -308,6 +333,15 @@ dependencies = [
  "tiff",
 ]
 
+[[package]]
+name = "ir"
+version = "0.1.0"
+dependencies = [
+ "ahash",
+ "ron",
+ "serde",
+]
+
 [[package]]
 name = "jpeg-decoder"
 version = "0.3.0"
@@ -323,6 +357,12 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "03087c2bad5e1034e8cace5926dec053fb3790248370865f5117a7d0213354c8"
 
+[[package]]
+name = "libc"
+version = "0.2.152"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13e3bf6590cbc649f4d1a3eefc9d5d6eb746f5200ffb04e5e142700b8faa56e7"
+
 [[package]]
 name = "lock_api"
 version = "0.4.11"
@@ -373,13 +413,19 @@ dependencies = [
  "autocfg",
 ]
 
+[[package]]
+name = "once_cell"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+
 [[package]]
 name = "pl-cli"
 version = "0.1.0"
 dependencies = [
  "clap",
  "executor",
- "rpl",
+ "ir",
 ]
 
 [[package]]
@@ -454,14 +500,6 @@ dependencies = [
  "serde_derive",
 ]
 
-[[package]]
-name = "rpl"
-version = "0.1.0"
-dependencies = [
- "ron",
- "serde",
-]
-
 [[package]]
 name = "scopeguard"
 version = "1.2.0"
@@ -549,6 +587,18 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
 
+[[package]]
+name = "version_check"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
 [[package]]
 name = "weezl"
 version = "0.1.7"
@@ -621,6 +671,26 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dff9641d1cd4be8d1a070daf9e3773c5f67e78b4d9d42263020c057706765c04"
 
+[[package]]
+name = "zerocopy"
+version = "0.7.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74d4d3961e53fa4c9a25a8637fc2bfaf2595b3d3ae34875568a5cf64787716be"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "zune-inflate"
 version = "0.2.54"

Cargo.toml

@@ -1,8 +1,8 @@
 [workspace]
 members = [ 
   "crates/executor", 
-  "crates/pl-cli", 
+  "crates/ir",
-  "crates/rpl"
+  "crates/cli", 
 ]
 resolver = "2"
 

crates/cli/Cargo.toml

@@ -6,9 +6,9 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-clap = { workspace = true, features = [ "derive" ] }
+clap = { workspace = true }
-rpl = { path = "../rpl" }
 executor = { path = "../executor" }
+ir = { path = "../ir" }
 
 [lints]
 workspace = true

crates/cli/src/main.rs

@@ -14,7 +14,7 @@ fn main() {
 
     let f = fs::read_to_string(args.file)
         .expect("reading IR failed — come back to this later handle errors properly");
-    let pl = rpl::from_ron(&f);
+    let pl = ir::from_ron(&f).expect("handle me properly");
 
-    execute_all(pl.0);
+    execute_all(pl);
 }

crates/executor/Cargo.toml

@@ -8,7 +8,7 @@ edition = "2021"
 [dependencies]
 clap = { workspace = true, features = [ "derive" ] }
 image = "0.24"
-rpl = { path = "../rpl" }
+ir = { path = "../ir" }
 
 [lints]
 workspace = true

crates/ir/Cargo.toml

@@ -1,13 +1,14 @@
 [package]
-name = "rpl"
+name = "ir"
 version = "0.1.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-serde = { version = "1.0.193", features = [ "derive" ] }
+ahash = { version = "0.8.7", features = ["serde"] }
 ron = "0.8"
+serde = { version = "1.0.193", features = ["derive"] }
 
 [lints]
 workspace = true

crates/ir/src/instruction/mod.rs

@@ -3,8 +3,8 @@ use serde::{Deserialize, Serialize};
 pub mod read;
 pub mod write;
 
-#[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub enum Instruction {
+pub enum Kind {
     Read(read::Read),
     Write(write::Write),
     Math(Math),
@@ -13,7 +13,7 @@ pub enum Instruction {
     Filter(Filter),
 }
 
-#[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum Math {
     Add,
     Subtract,
@@ -21,7 +21,7 @@ pub enum Math {
     Divide,
 }
 
-#[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum Blend {
     Normal,
     Multiply,
@@ -34,14 +34,14 @@ pub enum Blend {
     Lighten,
 }
 
-#[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum Noise {
     Perlin,
     Simplex,
     Voronoi,
 }
 
-#[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum Filter {
     Invert,
 }

crates/ir/src/instruction/read.rs

@@ -1,18 +1,18 @@
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 
-#[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Read {
     pub source: SourceType,
     pub format: SourceFormat,
 }
 
-#[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum SourceType {
     File(PathBuf),
 }
 
-#[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum SourceFormat {
     Jpeg,
     Png,

crates/ir/src/instruction/write.rs

@@ -1,18 +1,18 @@
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 
-#[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Write {
     pub target: TargetType,
     pub format: TargetFormat,
 }
 
-#[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum TargetType {
     File(PathBuf),
 }
 
-#[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum TargetFormat {
     Jpeg,
     Png,

crates/ir/src/lib.rs

@@ -0,0 +1,105 @@
+use std::ops::RangeInclusive;
+
+use serde::{Deserialize, Serialize};
+
+pub mod instruction;
+
+pub type Map<K, V> = ahash::AHashMap<K, V>;
+pub type Set<V> = ahash::AHashSet<V>;
+
+pub fn from_ron(source: &str) -> ron::error::SpannedResult<GraphIr> {
+    ron::from_str(source)
+}
+
+/// The toplevel representation of a whole pipeline.
+///
+/// Pipelines may not be fully linear. They may branch out and recombine later on.
+/// As such, the representation for them which is currently used is a
+/// [**D**irected **A**cyclic **G**raph](https://en.wikipedia.org/wiki/Directed_acyclic_graph)
+/// .
+///
+/// For those who are already familiar with graphs, a DAG is one, except that:
+///
+/// - It is **directed**: Edges have a direction they point to.
+///   In this case, edges point from the outputs of streamers to inputs of consumers.
+/// - It is **acyclic**: Those directed edges may not form loops.
+///   In other words, if one follows edges only in their direction, it must be impossible
+///   to come back to an already visited node.
+///
+/// Here, if an edge points from _A_ to _B_ (`A --> B`),
+/// then _A_ is called a **dependency** of _B_,
+/// and _B_ is called a **dependent** of _A_.
+///
+/// The DAG also enables another neat operation:
+/// [Topological sorting](https://en.wikipedia.org/wiki/Topological_sorting).
+/// This allows to put the entire graph into a linear list,
+/// where it's guaranteed that once a vertex is visited,
+/// all dependencies of it will have been visited already as well.
+///
+/// The representation used here in specific is a bit more complicated,
+/// since **instructions** directly aren't just connected to one another,
+/// but their **sockets** are instead.
+///
+/// So the vertices of the DAG are the **sockets**
+/// (which are either [`id::Input`] or [`id::Output`] depending on the direction),
+/// and each **socket** in turn belongs to an **instruction**.
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
+pub struct GraphIr {
+    /// "Backbone" storage of all **instruction** IDs to
+    /// what **kind of instruction** they are.
+    instructions: Map<id::Instruction, instruction::Kind>,
+
+    /// How the data flows forward. **Dependencies** map to **dependents** here.
+    edges: Map<id::Output, Set<id::Input>>,
+    /// How the data flows backward. **Dependents** map to **dependencies** here.
+    rev_edges: Map<id::Input, Set<id::Output>>,
+}
+
+pub mod id {
+    use serde::{Deserialize, Serialize};
+
+    use crate::Span;
+
+    /// One specific instruction, and where it is found in code.
+    ///
+    /// It does **not** contain what kind of instruction this is.
+    /// Refer to [`crate::instruction::Kind`] for this instead.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash, Deserialize, Serialize)]
+    pub struct Instruction(Span);
+
+    impl Instruction {
+        /// Where this instruction is written down.
+        pub fn span(&self) -> &Span {
+            &self.0
+        }
+    }
+
+    /// On an **instruction**, accepts incoming data.
+    ///
+    /// An **instruction** cannot run if any of these are not connected.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash, Deserialize, Serialize)]
+    pub struct Input(Socket);
+
+    /// On an **instruction**, returns outgoing data to be fed to [`Input`]s.
+    ///
+    /// In contrast to [`Input`]s, [`Output`]s may be used or unused.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash, Deserialize, Serialize)]
+    pub struct Output(Socket);
+
+    /// An unspecified socket on a specific **instruction**,
+    /// and where it is on that **instruction**.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash, Deserialize, Serialize)]
+    pub struct Socket {
+        pub belongs_to: Instruction,
+        pub index: SocketIdx,
+    }
+
+    /// Where a [`Socket`] is on an **instruction**.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash, Deserialize, Serialize)]
+    pub struct SocketIdx(pub u16);
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Deserialize, Serialize)]
+pub struct Span {
+    range: RangeInclusive<usize>,
+}

crates/rpl/src/lib.rs

@@ -1,51 +0,0 @@
-use instructions::Instruction;
-use serde::{Deserialize, Serialize};
-
-pub mod instructions;
-
-/// # Panics
-///
-/// Panics if deserialization fails. lol.
-#[must_use]
-pub fn from_ron(raw: &str) -> Rpl {
-    ron::from_str(raw).expect("come back later and handle me correctly")
-}
-
-#[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
-pub struct Rpl(pub Vec<Instruction>);
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::instructions::{
-        read::{SourceFormat, SourceType},
-        write::{TargetFormat, TargetType},
-        Math,
-    };
-
-    #[test]
-    fn test_simple_deserialize() {
-        const TEST_DATA: &str = concat!(
-            "([",
-            "Read( (source: File(\"~/example/file.png\"), format: Png) ),",
-            "Math(Add),",
-            "Write(( target: File(\"~/example/out.jpg\"), format: Jpeg)),",
-            "])",
-        );
-
-        assert_eq!(
-            from_ron(TEST_DATA),
-            Rpl(vec![
-                Instruction::Read(instructions::read::Read {
-                    source: SourceType::File("~/example/file.png".into()),
-                    format: SourceFormat::Png
-                }),
-                Instruction::Math(Math::Add),
-                Instruction::Write(instructions::write::Write {
-                    target: TargetType::File("~/example/out.jpg".into()),
-                    format: TargetFormat::Jpeg
-                })
-            ])
-        );
-    }
-}