♻️ rename crate: imperfect → terni (Latin: threefold)

The crate is terni. The type is Imperfect. The address changed. The name didn't.

Author: Mara

Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "imperfect"
+name = "terni"
 version = "0.1.0"
 edition = "2021"
 license = "Apache-2.0"

README.md

@@ -1,19 +1,19 @@
-# Imperfect
+# terni
 
 > I wanna thank Brene Brown for her work.
 
 Ternary error handling for Rust. Because computation is not binary.
 
-[![crates.io](https://img.shields.io/crates/v/imperfect.svg)](https://crates.io/crates/imperfect)
-[![docs.rs](https://docs.rs/imperfect/badge.svg)](https://docs.rs/imperfect)
-[![license](https://img.shields.io/crates/l/imperfect.svg)](https://github.com/systemic-engineering/prism/blob/main/imperfect/LICENSE)
+[![crates.io](https://img.shields.io/crates/v/terni.svg)](https://crates.io/crates/terni)
+[![docs.rs](https://docs.rs/terni/badge.svg)](https://docs.rs/terni)
+[![license](https://img.shields.io/crates/l/terni.svg)](https://github.com/systemic-engineering/prism/blob/main/imperfect/LICENSE)
 
 ## `eh`
 
 The type. Three states instead of two.
 
 ```rust
-use imperfect::{Imperfect, ConvergenceLoss};
+use terni::{Imperfect, ConvergenceLoss};
 
 let perfect: Imperfect<u32, String, ConvergenceLoss> = Imperfect::Success(42);
 let lossy = Imperfect::Partial(42, ConvergenceLoss::new(3));
@@ -24,7 +24,7 @@ assert!(lossy.is_partial());
 assert!(failed.is_err());
 ```
 
-[`Loss`](https://docs.rs/imperfect/latest/imperfect/trait.Loss.html) measures what didn't survive. It's a monoid: `zero()` identity, `combine` associative, `total()` absorbing.
+[`Loss`](https://docs.rs/terni/latest/terni/trait.Loss.html) measures what didn't survive. It's a monoid: `zero()` identity, `combine` associative, `total()` absorbing.
 
 Three loss types ship with the crate:
 - **`ConvergenceLoss`** — distance to crystal. Combine: max.
@@ -38,7 +38,7 @@ Three loss types ship with the crate:
 The bind. Chain operations, accumulate loss.
 
 ```rust
-use imperfect::{Imperfect, ConvergenceLoss};
+use terni::{Imperfect, ConvergenceLoss};
 
 let result = Imperfect::<i32, String, ConvergenceLoss>::Success(1)
     .eh(|x| Imperfect::Success(x * 2))
@@ -51,7 +51,7 @@ assert!(result.is_partial());
 For explicit context with loss accumulation:
 
 ```rust
-use imperfect::{Imperfect, Eh, ConvergenceLoss};
+use terni::{Imperfect, Eh, ConvergenceLoss};
 
 let mut eh = Eh::new();
 let a = eh.eh(Imperfect::<i32, String, ConvergenceLoss>::Success(1)).unwrap();

docs/context.md

@@ -11,7 +11,7 @@ The `.eh()` pipeline is clean when every step returns `Imperfect`. But sometimes
 ## Basic usage
 
 ```rust
-use imperfect::{Imperfect, Eh, ConvergenceLoss};
+use terni::{Imperfect, Eh, ConvergenceLoss};
 
 fn process() -> Imperfect<i32, String, ConvergenceLoss> {
     let mut eh = Eh::new();
@@ -42,7 +42,7 @@ fn process() -> Imperfect<i32, String, ConvergenceLoss> {
 Creates a context with zero accumulated loss.
 
 ```rust
-use imperfect::{Eh, ConvergenceLoss};
+use terni::{Eh, ConvergenceLoss};
 
 let eh: Eh<ConvergenceLoss> = Eh::new();
 assert!(eh.loss().is_none());
@@ -63,7 +63,7 @@ Aliases for `.eh()`, same as on `Imperfect` itself.
 Inspect accumulated loss without consuming the context. Returns `None` if no loss has accumulated (all steps were Success).
 
 ```rust
-use imperfect::{Imperfect, Eh, ConvergenceLoss};
+use terni::{Imperfect, Eh, ConvergenceLoss};
 
 let mut eh: Eh<ConvergenceLoss> = Eh::new();
 assert!(eh.loss().is_none());
@@ -90,7 +90,7 @@ This is the exit point. It converts back from `Result`-land to `Imperfect`.
 `Eh` is the bridge between `Imperfect` and `Result`. Inside an `Eh` block, you can freely mix both:
 
 ```rust
-use imperfect::{Imperfect, Eh, ConvergenceLoss};
+use terni::{Imperfect, Eh, ConvergenceLoss};
 use std::num::ParseIntError;
 
 fn parse_and_validate(input: &str) -> Imperfect<i32, String, ConvergenceLoss> {
@@ -132,7 +132,7 @@ The key insight: `Eh.eh()` returns `Result`, so you can match on it for early re
 ## Example: payment verification
 
 ```rust
-use imperfect::{Imperfect, Eh, ConvergenceLoss};
+use terni::{Imperfect, Eh, ConvergenceLoss};
 
 struct Payment { amount: u64, currency: String }
 struct VerifiedPayment { amount: u64, currency: String, risk_score: f64 }

docs/loss-types.md

@@ -31,7 +31,7 @@ Distance to crystal. How many steps remain before the result is fully converged.
 **Combine semantics:** `max`. The furthest-from-crystal step dominates. If one step is 3 iterations away and another is 7, the pipeline is 7 iterations away.
 
 ```rust
-use imperfect::{Imperfect, ConvergenceLoss};
+use terni::{Imperfect, ConvergenceLoss};
 
 // Solver ran but didn't fully converge
 let step1 = Imperfect::<f64, String, ConvergenceLoss>::Partial(3.14, ConvergenceLoss::new(5));
@@ -55,7 +55,7 @@ Which dimensions were dark during observation. Tracks both which specific dimens
 **Combine semantics:** Union of dark dimensions, max of aperture fraction. If step A missed dims [1, 3] and step B missed dims [2, 3], the pipeline missed [1, 2, 3].
 
 ```rust
-use imperfect::{Imperfect, ApertureLoss};
+use terni::{Imperfect, ApertureLoss};
 
 // Observed 8 of 10 dimensions — dims 2 and 7 were dark
 let step1 = Imperfect::<Vec<f64>, String, ApertureLoss>::Partial(
@@ -82,7 +82,7 @@ Decision uncertainty at a routing point. Measured as Shannon entropy of the rout
 **Combine semantics:** Max entropy (most uncertain routing dominates), min gap (tightest race dominates).
 
 ```rust
-use imperfect::{Imperfect, RoutingLoss};
+use terni::{Imperfect, RoutingLoss};
 
 // Routed to model A with moderate confidence
 let step1 = Imperfect::<String, String, RoutingLoss>::Partial(
@@ -106,7 +106,7 @@ assert_eq!(result.loss().runner_up_gap(), 0.3);
 Implement `Loss` for any domain-specific measurement. The only requirements: `Clone + Default`, the four trait methods, and `combine` must be associative.
 
 ```rust
-use imperfect::{Loss, Imperfect};
+use terni::{Loss, Imperfect};
 
 /// Tracks accumulated latency as loss.
 #[derive(Clone, Debug, PartialEq, Default)]

docs/migration.md

@@ -33,7 +33,7 @@ fn process(input: &str) -> Result<i32, String> {
 After:
 
 ```rust
-use imperfect::{Imperfect, ConvergenceLoss};
+use terni::{Imperfect, ConvergenceLoss};
 
 fn process(input: &str) -> Imperfect<i32, String, ConvergenceLoss> {
     let n: i32 = match input.parse() {
@@ -68,7 +68,7 @@ fn run(a: &str, b: &str) -> Result<i32, String> {
 After:
 
 ```rust
-use imperfect::{Imperfect, Eh, ConvergenceLoss};
+use terni::{Imperfect, Eh, ConvergenceLoss};
 
 # fn process(_: &str) -> Imperfect<i32, String, ConvergenceLoss> {
 #     Imperfect::Success(1)
@@ -84,7 +84,7 @@ fn run(a: &str, b: &str) -> Imperfect<i32, String, ConvergenceLoss> {
 Or use the pipeline directly:
 
 ```rust
-use imperfect::{Imperfect, ConvergenceLoss};
+use terni::{Imperfect, ConvergenceLoss};
 
 # fn process(_: &str) -> Imperfect<i32, String, ConvergenceLoss> {
 #     Imperfect::Success(1)
@@ -99,7 +99,7 @@ fn run(a: &str, b: &str) -> Imperfect<i32, String, ConvergenceLoss> {
 `From` conversions let `Imperfect` and `Result` coexist:
 
 ```rust
-use imperfect::{Imperfect, ConvergenceLoss};
+use terni::{Imperfect, ConvergenceLoss};
 
 // Result → Imperfect (Ok becomes Success, Err becomes Failure)
 let from_result: Imperfect<i32, String, ConvergenceLoss> =

docs/pipeline.md

@@ -19,7 +19,7 @@ Four rules. No exceptions.
 No loss on either side. The pipeline is perfect.
 
 ```rust
-use imperfect::{Imperfect, ConvergenceLoss};
+use terni::{Imperfect, ConvergenceLoss};
 
 let result = Imperfect::<i32, String, ConvergenceLoss>::Success(1)
     .eh(|x| Imperfect::Success(x + 1));
@@ -32,7 +32,7 @@ assert_eq!(result, Imperfect::Success(2));
 The function introduced loss. It carries forward.
 
 ```rust
-use imperfect::{Imperfect, ConvergenceLoss};
+use terni::{Imperfect, ConvergenceLoss};
 
 let result = Imperfect::<i32, String, ConvergenceLoss>::Success(1)
     .eh(|x| Imperfect::Partial(x + 1, ConvergenceLoss::new(3)));
@@ -46,7 +46,7 @@ assert_eq!(result.loss().steps(), 3);
 Both sides had loss. Losses combine.
 
 ```rust
-use imperfect::{Imperfect, ConvergenceLoss};
+use terni::{Imperfect, ConvergenceLoss};
 
 let result = Imperfect::<i32, String, ConvergenceLoss>::Partial(1, ConvergenceLoss::new(3))
     .eh(|x| Imperfect::Partial(x + 1, ConvergenceLoss::new(5)));
@@ -60,7 +60,7 @@ assert_eq!(result.loss().steps(), 5);  // max(3, 5) for ConvergenceLoss
 Failure short-circuits. If the input is Failure, `f` is never called. If `f` returns Failure, prior loss is discarded — the value is gone.
 
 ```rust
-use imperfect::{Imperfect, ConvergenceLoss};
+use terni::{Imperfect, ConvergenceLoss};
 
 // Failure input: f is never called
 let result = Imperfect::<i32, String, ConvergenceLoss>::Failure("gone".into())
@@ -80,7 +80,7 @@ assert!(result.is_err());
 `.eh()` composes naturally. Each step sees the value from the previous step. Loss accumulates across the entire chain.
 
 ```rust
-use imperfect::{Imperfect, ConvergenceLoss};
+use terni::{Imperfect, ConvergenceLoss};
 
 fn validate(input: &str) -> Imperfect<i32, String, ConvergenceLoss> {
     match input.parse::<i32>() {
@@ -123,7 +123,7 @@ assert_eq!(result.loss().steps(), 1);  // max(1, 1) = 1 — sign corrected + cla
 Use whichever makes your code clearest. They compile to the same thing.
 
 ```rust
-use imperfect::{Imperfect, ConvergenceLoss};
+use terni::{Imperfect, ConvergenceLoss};
 
 // All three are identical
 let a = Imperfect::<i32, String, ConvergenceLoss>::Success(1)

docs/terni-functor.md

@@ -37,7 +37,7 @@ For `.eh()` to be a genuine bind, it must satisfy three laws:
 `return a >>= f  ==  f a`
 
 ```rust
-use imperfect::{Imperfect, ConvergenceLoss};
+use terni::{Imperfect, ConvergenceLoss};
 
 fn f(x: i32) -> Imperfect<i32, String, ConvergenceLoss> {
     Imperfect::Partial(x * 2, ConvergenceLoss::new(1))
@@ -56,7 +56,7 @@ assert_eq!(left, right);
 `m >>= return  ==  m`
 
 ```rust
-use imperfect::{Imperfect, ConvergenceLoss};
+use terni::{Imperfect, ConvergenceLoss};
 
 let m = Imperfect::<i32, String, ConvergenceLoss>::Partial(5, ConvergenceLoss::new(3));
 
@@ -72,7 +72,7 @@ Binding through `Success` (return) preserves the original value and loss.
 `(m >>= f) >>= g  ==  m >>= (|x| f(x) >>= g)`
 
 ```rust
-use imperfect::{Imperfect, ConvergenceLoss};
+use terni::{Imperfect, ConvergenceLoss};
 
 fn f(x: i32) -> Imperfect<i32, String, ConvergenceLoss> {
     Imperfect::Partial(x + 1, ConvergenceLoss::new(2))

src/lib.rs

@@ -32,7 +32,7 @@
 //! ### Pipeline
 //!
 //! ```rust
-//! use imperfect::{Imperfect, ConvergenceLoss};
+//! use terni::{Imperfect, ConvergenceLoss};
 //!
 //! let result = Imperfect::<i32, String, ConvergenceLoss>::Success(1)
 //!     .eh(|x| Imperfect::Success(x * 2))
@@ -45,7 +45,7 @@
 //! ### Explicit Context
 //!
 //! ```rust
-//! use imperfect::{Imperfect, Eh, ConvergenceLoss};
+//! use terni::{Imperfect, Eh, ConvergenceLoss};
 //!
 //! let mut eh = Eh::new();
 //! let a = eh.imp(Imperfect::<i32, String, ConvergenceLoss>::Success(1)).unwrap();