feat: add OpEmitter trait for eager AD execution (#1)

Minimal trait with single method add_op(). FragmentBuilder implements it.
AD transpose rules can target this trait to enable both graph-building
and eager execution through the same code path.

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: shinaoka

Cargo.toml

@@ -4,3 +4,5 @@ version = "0.1.0"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 publish = false
+
+[workspace]

src/lib.rs

@@ -9,5 +9,5 @@ pub mod resolve;
 pub mod traits;
 pub mod types;
 
-pub use traits::{EvalGraphOp, GraphOp};
+pub use traits::{EvalGraphOp, GraphOp, OpEmitter};
 pub use types::{GlobalOpKey, GlobalValKey, LocalOpId, LocalValId, OpMode, ValRef};

src/traits.rs

@@ -1,5 +1,8 @@
 use std::hash::Hash;
 
+use crate::fragment::FragmentBuilder;
+use crate::types::{LocalValId, OpMode, ValRef};
+
 /// Operation node trait. `computegraph` is fully generic over this abstraction.
 ///
 /// `GraphOp` captures the metadata of an operation (input/output counts,
@@ -37,6 +40,46 @@ pub trait GraphOp: Clone + std::fmt::Debug + Hash + Eq + Send + Sync + 'static {
     fn n_outputs(&self) -> usize;
 }
 
+/// Minimal trait for emitting operations into a computation context.
+///
+/// AD transpose rules use only this interface, enabling both graph-building
+/// (`FragmentBuilder`) and eager execution through the same code.
+///
+/// # Examples
+///
+/// ```ignore
+/// use computegraph::{FragmentBuilder, GraphOp, OpEmitter, OpMode, ValRef};
+///
+/// #[derive(Clone, Debug, Hash, PartialEq, Eq)]
+/// enum UnaryOp {
+///     Identity,
+/// }
+///
+/// impl GraphOp for UnaryOp {
+///     type Operand = f64;
+///     type Context = ();
+///     type InputKey = &'static str;
+///
+///     fn n_inputs(&self) -> usize { 1 }
+///     fn n_outputs(&self) -> usize { 1 }
+/// }
+///
+/// let mut builder = FragmentBuilder::<UnaryOp>::new();
+/// let x = builder.add_input("x");
+/// let ys = builder.add_op(UnaryOp::Identity, vec![ValRef::Local(x)], OpMode::Primal);
+/// assert_eq!(ys.len(), 1);
+/// ```
+pub trait OpEmitter<Op: GraphOp> {
+    /// Emits an operation with the given inputs and mode, returning output ids.
+    fn add_op(&mut self, op: Op, inputs: Vec<ValRef<Op>>, mode: OpMode) -> Vec<LocalValId>;
+}
+
+impl<Op: GraphOp> OpEmitter<Op> for FragmentBuilder<Op> {
+    fn add_op(&mut self, op: Op, inputs: Vec<ValRef<Op>>, mode: OpMode) -> Vec<LocalValId> {
+        FragmentBuilder::add_op(self, op, inputs, mode)
+    }
+}
+
 /// Extension trait that adds evaluation capability to a [`GraphOp`].
 ///
 /// # Examples