Struct CoercionResult 

pub struct CoercionResult<T> {
    pub value: T,
    pub flags: Vec<CoercionFlag>,
    pub confidence: f32,
}

Result of a coercion operation with transparency.

Tracks the value, all coercions applied, and confidence score.

Fields

value: T

The coerced value

flags: Vec<CoercionFlag>

All coercion flags applied

confidence: f32

Confidence score (0.0-1.0)

Implementations

impl<T> CoercionResult<T>

pub fn new(value: T) -> Self

Create a new coercion result with perfect confidence.

Example

use simple_agent_type::coercion::CoercionResult;

let result = CoercionResult::new(42);
assert_eq!(result.value, 42);
assert_eq!(result.confidence, 1.0);
assert!(result.flags.is_empty());

pub fn with_confidence(value: T, confidence: f32) -> Self

Create a result with a specific confidence.

pub fn set_confidence(self, confidence: f32) -> Self

Set the confidence score (builder pattern).

pub fn with_flag(self, flag: CoercionFlag) -> Self

Add a coercion flag.

pub fn with_flags(self, flags: Vec<CoercionFlag>) -> Self

Add multiple coercion flags.

pub fn was_coerced(&self) -> bool

Check if any coercions were applied.

Example

use simple_agent_type::coercion::{CoercionResult, CoercionFlag};

let result = CoercionResult::new(42);
assert!(!result.was_coerced());

let result = result.with_flag(CoercionFlag::StrippedMarkdown);
assert!(result.was_coerced());

pub fn is_confident(&self, threshold: f32) -> bool

Check if confidence meets a threshold.

Example

use simple_agent_type::coercion::CoercionResult;

let result = CoercionResult::with_confidence(42, 0.8);
assert!(result.is_confident(0.7));
assert!(!result.is_confident(0.9));

pub fn has_major_coercions(&self) -> bool

Check if any major coercions were applied.

pub fn map<U, F>(self, f: F) -> CoercionResult<U>

where F: FnOnce(T) -> U,

Map the value while preserving flags and confidence.

Trait Implementations

impl<T: Clone> Clone for CoercionResult<T>

fn clone(&self) -> CoercionResult<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for CoercionResult<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for CoercionResult<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: PartialEq> PartialEq for CoercionResult<T>

fn eq(&self, other: &CoercionResult<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for CoercionResult<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> StructuralPartialEq for CoercionResult<T>