I now have a more acceptable frontend sense.

Cargo.toml

@@ -6,3 +6,4 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+slab = "0.4.8"

src/builder/arith.rs

@@ -0,0 +1,12 @@
+use super::ctx::Reference;
+
+enum Opcode {
+  Add,
+  Mul,
+}
+
+pub struct Expr {
+  opcode: Opcode,
+  operands: Vec<Reference>
+}
+

src/builder/context.rs

@@ -0,0 +1,75 @@
+use slab;
+
+use crate::{Data, Module};
+
+use super::data::Expr;
+
+pub enum Element {
+  Module(Module),
+  Data(Data),
+  Expr(Expr),
+}
+
+impl Element {
+
+  fn set_key(&mut self, key: usize) {
+    match self {
+      Element::Module(module) => { module.key = key; }
+      _ => panic!("Element::set_key: unexpected element type"),
+    }
+  }
+
+}
+
+pub struct Context {
+  slab: slab::Slab<Element>,
+}
+
+pub trait IsElement {
+  fn into_reference(key: usize) -> Reference;
+}
+
+macro_rules! register_element {
+  ($name:ident) => {
+
+    impl Into<Element> for $name {
+      fn into(self) -> Element {
+        Element::$name(self)
+      }
+    }
+
+    impl IsElement for $name {
+      fn into_reference(key: usize) -> Reference {
+        Reference::Module(key)
+      }
+    }
+
+  };
+}
+
+register_element!(Module);
+register_element!(Data);
+
+
+pub enum Reference {
+  Module(usize),
+  Data(usize),
+  Expr(usize),
+}
+
+impl Context {
+
+  pub fn new() -> Self {
+    Context {
+      slab: slab::Slab::new(),
+    }
+  }
+
+  pub fn insert<T: Into<Element> + IsElement>(&mut self, elem: T) -> Reference {
+    let key = self.slab.insert(elem.into());
+    self.slab.get_mut(key).unwrap().set_key(key);
+    T::into_reference(key)
+  }
+
+}
+

src/builder/data.rs

@@ -1,4 +1,23 @@
+use crate::Context;
+
+use super::ctx::Reference;
+
 pub struct Data {
+  parent: Option<Reference>,
+  name: String,
   bits: usize,
 }
 
+impl Data {
+
+  pub fn new(ctx: &mut Context, name: &str, bits: usize) -> Reference {
+    let res = Data {
+      parent: None,
+      name: name.to_string(),
+      bits,
+    };
+    ctx.insert(res)
+  }
+
+}
+

src/builder/mod.rs

@@ -1,2 +1,5 @@
-mod data;
-mod module;
+pub mod data;
+pub mod module;
+pub mod context;
+pub mod arith;
+

src/builder/module.rs

@@ -1,8 +1,26 @@
-use super::data::Data;
+use super::{ctx::{Context, Reference}, data::Data};
 
-struct Module {
+pub struct Module {
+  pub(crate) key: usize,
+  name: String,
   subscriber: Vec<i32>,
   inputs: Vec<Data>,
   outputs: Vec<Data>,
 }
 
+impl Module {
+
+  pub fn new(ctx: &mut Context, name: &str, inputs: Vec<Data>) -> Reference {
+    let mut res = Module {
+      key: 0,
+      name: name.to_string(),
+      subscriber: Vec::new(),
+      inputs,
+      outputs: Vec::new(),
+    };
+    ctx.insert(res)
+  }
+
+
+}
+

src/lib.rs

@@ -1,2 +1,6 @@
 pub mod builder;
 
+pub use builder::module::Module;
+pub use builder::data::Data;
+pub use builder::ctx::Context;
+