Struct Transform 

pub struct Transform<I, O> { /* private fields */ }

A composable transformation pipeline

Transform<I, O> represents a transformation from type I to type O. It can be composed with other transforms using the add method.

Type Safety

The type system ensures that transforms can only be composed if their input/output types are compatible. For example:

let t1: Transform<String, TokenStream> = ...;
let t2: Transform<Document, String> = ...;

// This will fail to compile - TokenStream != Document
let bad = t1.add_transform(&t2);

Implementations

impl<I, O> Transform<I, O>

pub fn identity() -> Self

where I: Clone + 'static, O: From<I> + 'static,

Create a new identity transform that passes input through unchanged

Note: This only works when I = O

pub fn from_fn<F>(f: F) -> Self

where F: Fn(I) -> Result<O, TransformError> + Send + Sync + 'static,

Create a transform from a function

pub fn then<O2, S>(self, stage: S) -> Transform<I, O2>

where S: Runnable<O, O2> + Send + Sync + 'static, I: 'static, O: 'static, O2: 'static,

Add a stage to this transform, returning a new transform with extended output type

This is the core composition method. It chains this transform’s output into the next stage’s input, creating a new transform from I to O2.

Type Safety

The compiler ensures that the stage’s input type matches this transform’s output type.

Example

let t1: Transform<String, Tokens> = ...;
let t2: Transform<Tokens, Ast> = ...;

let combined: Transform<String, Ast> = t1.then_transform(&t2);

pub fn then_transform<O2>( self, next: &'static Transform<O, O2>, ) -> Transform<I, O2>

where I: 'static, O: 'static, O2: 'static,

Chain another transform to this transform

This is similar to then but takes a Transform instead of a Runnable. Useful for composing pre-built transform pipelines.

The referenced transform must have a static lifetime (typically created with lazy_static!).

pub fn run(&self, input: I) -> Result<O, TransformError>

Execute this transform on the given input

impl<I, O> Transform<I, O>

pub fn new<F>(f: F) -> Self

where F: Fn(I) -> Result<O, TransformError> + Send + Sync + 'static,

Create a new transform with no stages (useful as a starting point for composition)

Trait Implementations

impl<I, O> Runnable<I, O> for Transform<I, O>

where I: 'static, O: 'static,

fn run(&self, input: I) -> Result<O, TransformError>

Execute this transformation on the input