Tryparse

https://docs.rs/tryparse/latest/
Admin
A forgiving parser that converts messy LLM responses into strongly-typed Rust structs, handling...
Tokens:139,398
Snippets:836
Trust Score:9.7
Update:11 months ago
Show doc for...
Tokens:
Raw
### FlexibleParser Default Example (Rust)

Source: https://docs.rs/tryparse/latest/src/tryparse/parser/mod

Demonstrates how to create a default `FlexibleParser` and use it to parse a JSON string. It asserts that the parsing is successful and returns at least one candidate. This example showcases the basic usage of the parser for valid JSON input.

```rust
use tryparse::parser::FlexibleParser;

let parser = FlexibleParser::default();
let candidates = parser.parse(r#"{"name": "Alice"}"#).unwrap();
assert!(!candidates.is_empty());
```

--------------------------------

### Example Usage of YamlStrategy - Rust

Source: https://docs.rs/tryparse/latest/tryparse/parser/strategies/struct

Demonstrates how to use the YamlStrategy to parse a YAML input string. It shows the instantiation of the strategy, the input format, and asserting that parsing yields results.

```rust
use tryparse::parser::strategies::{ParsingStrategy, YamlStrategy};

let strategy = YamlStrategy::default();
let input = "name: Alice\nage: 30";
let candidates = strategy.parse(input).unwrap();
assert!(!candidates.is_empty());
```

--------------------------------

### Configure Custom Parsing Strategies - Rust

Source: https://docs.rs/tryparse/latest/src/tryparse/parser/mod

Demonstrates how to initialize the FlexibleParser with a custom set of parsing strategies. This example shows the creation of a parser using only the DirectJsonStrategy and verifies the strategy count and names.

```Rust
#[test]
fn test_with_custom_strategies() {
    let strategies: Vec<Box<dyn ParsingStrategy>> = vec![Box::new(DirectJsonStrategy)];
    let parser = FlexibleParser::with_strategies(strategies);

    assert_eq!(parser.strategy_count(), 1);
    assert_eq!(parser.strategy_names()[0], "direct_json");
}
```

--------------------------------

### Initialize StructDeserializer

Source: https://docs.rs/tryparse/latest/tryparse/deserializer/struct_coercer/struct

Creates a new instance of StructDeserializer with no fields pre-configured. This serves as the starting point for adding field descriptors.

```rust
pub fn new() -> Self
```

--------------------------------

### Rust HashMap Get Assertions

Source: https://docs.rs/tryparse/latest/src/tryparse/deserializer/primitives

This Rust code snippet demonstrates retrieving values from a HashMap using the `get` method and asserting their correctness with `assert_eq!`. It assumes the HashMap `map` has already been populated.

```rust
assert_eq!(map.get("one"), Some(&1));
        assert_eq!(map.get("three"), Some(&3));
```

--------------------------------

### Advanced Usage: Parsing with Candidate Results and FlexibleParser

Source: https://docs.rs/tryparse/latest/index

This example illustrates advanced `tryparse` functionalities, including retrieving all parsing candidates with metadata using `parse_with_candidates` and directly utilizing the `FlexibleParser`. This provides more granular control and insights into the parsing process. Requires `serde::Deserialize` for the target struct.

```Rust
use tryparse::{parse_with_candidates, parser::FlexibleParser};
use serde::Deserialize;

#[derive(Deserialize)]
struct Data {
    value: i32,
}

let response = r#"{ \"value\": \"42\" }"#;

// Get all candidates with metadata
let (result, candidates) = parse_with_candidates::<Data>(response).unwrap();

// Or use the parser directly
let parser = FlexibleParser::new();
let flex_values = parser.parse(response).unwrap();
```

--------------------------------

### Rust: Result::is_ok Method Example

Source: https://docs.rs/tryparse/latest/tryparse/error/type

Provides an example of the `is_ok` method for `Result<T, E>`, which returns `true` if the `Result` instance is the `Ok` variant and `false` otherwise. This is a common way to check for success without unwrapping the value.

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);

```

--------------------------------

### Rust Example Usage of Constraint Validation

Source: https://docs.rs/tryparse/latest/src/tryparse/constraints

This snippet demonstrates how to use the `Constraint` system in Rust. It shows defining a constraint for a positive age, validating it against a sample value, and asserting that the validation passed. This highlights the practical application of the constraint logic.

```rust
use tryparse::constraints::{Constraint, ConstraintLevel, ConstraintResult};

// Define a constraint that age must be positive
let age_positive = Constraint::new(
    ConstraintLevel::Assert,
    "age_positive",
    "age must be greater than 0"
);

// In your deserializer, validate the constraint
let age: i64 = 25;
let result = age_positive.validate(age > 0);
assert!(result.passed());

```

--------------------------------

### Schema Guided Parsing API

Source: https://docs.rs/tryparse/latest/src/tryparse/lib

Parses an LLM response using schema information for guided parsing. This function leverages compile-time schema information to improve parsing accuracy, including field name normalization and better error messages.

```APIDOC
## Schema Guided Parsing API

### Description
Parses an LLM response using schema information for guided parsing. This function leverages compile-time schema information to improve parsing accuracy, including field name normalization and better error messages.

### Method
`POST` (conceptual, as this is a function call)

### Endpoint
`N/A` (function within a library)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **input** (str) - Required - The raw LLM response string.

### Request Example
```rust
use tryparse::parse_with_schema;
use tryparse::schema::SchemaInfo;
use serde::Deserialize;

#[derive(Deserialize)]
struct User {
    user_name: String,
    age: u32,
}

impl SchemaInfo for User {
    fn schema() -> tryparse::schema::Schema {
        tryparse::schema::Schema::Object {
            name: "User".to_string(),
            fields: vec![
                tryparse::schema::Field::new("user_name", tryparse::schema::Schema::String)
                    .with_alias("userName")
                    .with_alias("UserName"),
                tryparse::schema::Field::new("age", tryparse::schema::Schema::Int),
            ],
        }
    }
}

let response = r#"{"userName": "Alice", "age": 30}"#;
let user: User = parse_with_schema(response).unwrap();
```

### Response
#### Success Response (200)
- **T** (type) - The deserialized data of type `T`, which must implement `SchemaInfo`.

#### Response Example
```json
{
  "user_name": "Alice",
  "age": 30
}
```

### Errors
- `ParseError::NoCandidates`: If no valid JSON could be extracted.
- `ParseError::DeserializeFailed`: If deserialization fails for all candidates.
```

--------------------------------

### Quick Start: Parsing LLM Responses to Rust Structs with tryparse

Source: https://docs.rs/tryparse/latest/index

This snippet demonstrates the basic usage of the `tryparse` crate to parse a messy LLM response into a Rust struct. It showcases automatic type coercion from string numbers to integers and handles unquoted keys. The `serde::Deserialize` trait is required for the target struct.

```Rust
use tryparse::parse;
use serde::Deserialize;

#[derive(Deserialize, Debug)]
struct User {
    name: String,
    age: u32,
}

// Parse messy LLM output with unquoted keys and string numbers
let messy_response = r#"{name: \"Alice\", age: \"30\"}"#;

let user: User = parse(messy_response).unwrap();
assert_eq!(user.name, "Alice");
assert_eq!(user.age, 30); // Automatically coerced from string
```

--------------------------------

### Rust: Open New JSON Collection in StateMachineParser

Source: https://docs.rs/tryparse/latest/src/tryparse/parser/state_machine

These Rust functions, `open_object` and `open_array`, are responsible for initiating a new JSON collection (object or array) within the StateMachineParser. They push a new `StackFrame` onto the parser's stack, indicating the start of a new collection and setting its type.

```rust
fn open_object(&mut self) -> Result<()> {
        self.stack.push(StackFrame::new(JsonCollection::Object));
        Ok(())
    }

    fn open_array(&mut self) -> Result<()> {
        self.stack.push(StackFrame::new(JsonCollection::Array));
        Ok(())
    }

```

--------------------------------

### Generic Blanket Implementations

Source: https://docs.rs/tryparse/latest/tryparse/deserializer/struct

Documentation for generic blanket implementations, including `Any`, `Borrow`, `BorrowMut`, `From`, `Into`, `TryFrom`, and `TryInto`.

```APIDOC
## Generic Blanket Implementations

### `impl<T> Any for T`

- **Description**: Provides the `type_id` method to get the `TypeId` of a type.
- **Method**: `type_id(&self) -> TypeId`

### `impl<T> Borrow<T> for T`

- **Description**: Provides the `borrow` method for immutable borrowing.
- **Method**: `borrow(&self) -> &T`

### `impl<T> BorrowMut<T> for T`

- **Description**: Provides the `borrow_mut` method for mutable borrowing.
- **Method**: `borrow_mut(&mut self) -> &mut T`

### `impl<T> From<T> for T`

- **Description**: Provides the `from` method to convert a value into itself.
- **Method**: `from(t: T) -> T`

### `impl<T, U> Into<U> for T where U: From<T>`

- **Description**: Provides the `into` method for type conversion when `From<T> for U` is implemented.
- **Method**: `into(self) -> U`

### `impl<T, U> TryFrom<U> for T where U: Into<T>`

- **Description**: Provides the `try_from` method for fallible type conversion.
- **Associated Type**: `Error = Infallible`
- **Method**: `try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`

### `impl<T, U> TryInto<U> for T where U: TryFrom<T>`

- **Description**: Provides the `try_into` method for fallible type conversion.
- **Associated Type**: `Error = <U as TryFrom<T>>::Error`
- **Method**: `try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`
```

--------------------------------

### Rust: Detect YAML Patterns

Source: https://docs.rs/tryparse/latest/src/tryparse/parser/strategies/yaml

A helper function `looks_like_yaml` determines if a given string input contains YAML-like patterns. It returns `false` for inputs starting with JSON-specific characters like '{' or '['. It then counts lines that contain a ':' (indicating a key-value pair) and are not list items (starting with '-'), excluding empty lines and comments. An input is considered YAML-like if it has at least two such key-value lines.

```rust
fn looks_like_yaml(input: &str) -> bool {
    let trimmed = input.trim();

    // Don't treat JSON as YAML
    if trimmed.starts_with('{') || trimmed.starts_with('[') {
        return false;
    }

    // Look for YAML patterns: key: value
    // Count lines that match "key: value" pattern
    let yaml_pattern_count = trimmed
        .lines()
        .filter(|line| {
            let line = line.trim();
            if line.is_empty() || line.starts_with('#') {
                return false;
            }
            // Check for "key: value" pattern
            line.contains(':') && !line.starts_with('-')
        })
        .count();

    // If we have at least 2 lines with key: value, likely YAML
    yaml_pattern_count >= 2
}
```

--------------------------------

### Get Transformations from StructDeserializer

Source: https://docs.rs/tryparse/latest/tryparse/deserializer/struct_coercer/struct

Retrieves a slice of the Transformations that have been applied during the deserialization process. This allows inspection of the coercion steps taken.

```rust
pub fn transformations(&self) -> &[Transformation]
```

--------------------------------

### FlexibleParser Custom Initialization (Rust)

Source: https://docs.rs/tryparse/latest/src/tryparse/parser/mod

Creates a `FlexibleParser` with a custom list of parsing strategies. The provided strategies are automatically sorted by their priority before being assigned to the parser. This allows for fine-grained control over the parsing order and selection of strategies.

```rust
pub fn with_strategies(mut strategies: Vec<Box<dyn ParsingStrategy>>) -> Self {
        strategies.sort_by_key(|s| s.priority());
        Self { strategies }
    }
```

--------------------------------

### Advanced Usage: Parsing with Multiple Candidates and Custom Parsers in Rust

Source: https://docs.rs/tryparse/latest/tryparse

Illustrates advanced `tryparse` functionalities, including retrieving all parsing candidates with metadata using `parse_with_candidates` and direct instantiation and usage of `FlexibleParser`. This allows for more granular control and analysis of the parsing process. Both methods require `serde::Deserialize` for the target struct.

```rust
use tryparse::{parse_with_candidates, parser::FlexibleParser};
use serde::Deserialize;

#[derive(Deserialize)]
struct Data {
    value: i32,
}

let response = r#"{"value": "42"}"#;

// Get all candidates with metadata
let (result, candidates) = parse_with_candidates::<Data>(response).unwrap();

// Or use the parser directly
let parser = FlexibleParser::new();
let flex_values = parser.parse(response).unwrap();

```

--------------------------------

### Rust: Get transformations slice

Source: https://docs.rs/tryparse/latest/src/tryparse/value

Returns an immutable slice of all `Transformation`s applied to this `FlexValue`. This allows inspecting the history of changes without modifying it.

```rust
/// Returns a reference to the transformations applied.
#[inline]
pub fn transformations(&self) -> &[Transformation] {
    &self.transformations
}
```

--------------------------------

### Generate JSON explanation for FlexValue

Source: https://docs.rs/tryparse/latest/src/tryparse/value

The `explanation_json` method converts a `FlexValue` object into a structured JSON. This JSON includes details about the value's source (e.g., direct, markdown, fixed, heuristic), confidence score, applied transformations, and maximum transformation depth. It utilizes the `serde_json::json` macro for creating JSON objects and relies on a `transformation_to_json` helper function.

```rust
/// let mut value = FlexValue::new(json!(42), Source::Direct);
/// value.add_transformation(Transformation::StringToNumber {
///     original: "42".to_string(),
/// });
///
/// let explanation = value.explanation_json();
/// assert!(explanation["transformations"].is_array());
/// assert!(explanation["score"].is_number());
/// ```
pub fn explanation_json(&self) -> Value {
    use serde_json::json;

    // Convert source to JSON
    let source_json = match &self.source {
        Source::Direct => json!({"type": "direct"}),
        Source::Markdown { lang } => json!({
            "type": "markdown",
            "language": lang,
        }),
        Source::Fixed { fixes } => json!({
            "type": "fixed",
            "fixes": fixes.iter().map(|f| f.description()).collect::<Vec<_>>(),
        }),
        Source::MultiJson { index } => json!({
            "type": "multi_json",
            "index": index,
        }),
        Source::MultiJsonArray => json!({"type": "multi_json_array"}),
        Source::Heuristic { pattern } => json!({
            "type": "heuristic",
            "pattern": pattern,
        }),
        Source::Yaml => json!({"type": "yaml"}),
    };

    // Convert transformations to JSON
    let transformations_json: Vec<Value> = self
        .transformations
        .iter()
        .map(transformation_to_json)
        .collect();

    // Calculate score
    let score = crate::scoring::score_candidate(self);

    json!({
        "source": source_json,
        "confidence": self.confidence,
        "score": score,
        "transformations": transformations_json,
        "transformation_count": self.transformations.len(),
        "max_transformation_depth": self.max_transformation_depth,
    })
}

```

--------------------------------

### Rust: Get confidence score

Source: https://docs.rs/tryparse/latest/src/tryparse/value

Returns the current confidence score of the `FlexValue`. A score closer to 1.0 indicates higher confidence in the value's integrity.

```rust
/// Returns the confidence score for this value.
///
/// Higher values (closer to 1.0) indicate more confident parsing.
#[inline]
pub const fn confidence(&self) -> f32 {
    self.confidence
}
```

--------------------------------

### Rust: Filter and Count Constraint Results

Source: https://docs.rs/tryparse/latest/tryparse/constraints/struct

Shows how to filter ConstraintResults to get only those for 'check'-level constraints and how to count the total number of constraints stored.

```rust
impl ConstraintResults {
    /// Returns all results for check-level constraints.
    pub fn checks(&self) -> Vec<&ConstraintResult>

    /// Returns the number of constraints.
    pub fn len(&self) -> usize
}
```

--------------------------------

### Rust: Initialize StateMachineParser

Source: https://docs.rs/tryparse/latest/src/tryparse/parser/state_machine

Provides the `new` constructor for the `StateMachineParser` struct. This initializes the parser's state, including an empty stack, zero position, and flags for string parsing.

```Rust
/// State machine parser for JSONish content.
///
/// This parser maintains a stack of collections being parsed and processes
/// the input character by character, making context-aware decisions.
#[derive(Debug, Clone)]
pub struct StateMachineParser {
    /// Stack of collection contexts (most recent on top)
    stack: Vec<StackFrame>,
    /// Current position in input
    position: usize,
    /// Whether we're currently inside a quoted string
    in_string: bool,
    /// Whether the last character was an escape
    escaped: bool,
    /// Accumulated candidates
    candidates: Vec<String>,
}

impl StateMachineParser {
    /// Create a new state machine parser.
    pub fn new() -> Self {
        Self {
            stack: Vec::new(),
            position: 0,
            in_string: false,
            escaped: false,
            candidates: Vec::new(),
        }
    }

    /// Parse the input and return JSON candidates.
    pub fn parse(&mut self, input: &str) -> Result<Vec<FlexValue>> {
        self.reset();

        let chars: Vec<char> = input.chars().collect();
        let len = chars.len();

        while self.position < len {
            let ch = chars[self.position];

            // Handle escape sequences
            if self.in_string {
                if self.escaped {
                    self.append_to_current(ch);
                    self.escaped = false;
                } else if ch == '\' {
                    self.append_to_current(ch);
                    self.escaped = true;
                } else if ch == '"' {
                    self.append_to_current(ch);
                    self.in_string = false;
                } else {
                    self.append_to_current(ch);
                }
                self.position += 1;
                continue;
            }
            // ... rest of the parsing logic ...
        }
        // Placeholder for the rest of the function
        unimplemented!("Parsing logic not fully implemented in this snippet.")
    }

    // Helper method to reset the parser state
    fn reset(&mut self) {
        self.stack.clear();
        self.position = 0;
        self.in_string = false;
        self.escaped = false;
        self.candidates.clear();
        // Potentially push initial Root context if needed
    }

    // Placeholder for appending character to current context
    fn append_to_current(&mut self, _ch: char) {
        // Implementation would go here
    }
}
```

--------------------------------

### Get Strategy Count - Rust

Source: https://docs.rs/tryparse/latest/src/tryparse/parser/mod

Returns the total number of registered strategies within the parser. This is a simple inline function that returns the length of the internal `strategies` vector.

```rust
pub fn strategy_count(&self) -> usize {
        self.strategies.len()
    }
```

--------------------------------

### Rust: Advanced Parsing with Candidates using TryParse

Source: https://docs.rs/tryparse/latest/src/tryparse/lib

Shows how to use `tryparse::parse_with_candidates` to obtain not only the deserialized result but also a vector of all potential parsing interpretations (candidates). This is useful for debugging or when multiple valid interpretations might exist. It also demonstrates direct usage of `FlexibleParser` for more granular control.

```rust
use tryparse::{parse_with_candidates, parser::FlexibleParser};
use serde::Deserialize;

#[derive(Deserialize)]
struct Data {
    value: i32,
}

let response = r#"{ "value": "42" }"#;

// Get all candidates with metadata
let (result, candidates) = parse_with_candidates::<Data>(response).unwrap();

// Or use the parser directly
let parser = FlexibleParser::new();
let flex_values = parser.parse(response).unwrap();

```

--------------------------------

### Rust: Get Current Context Depth

Source: https://docs.rs/tryparse/latest/src/tryparse/deserializer/traits

A constant function that returns the current depth of the CoercionContext. This is useful for tracking the recursion level during deserialization.

```rust
pub const fn depth(&self) -> usize {
    self.depth
}
```

--------------------------------

### CoercionContext: New Context Creation

Source: https://docs.rs/tryparse/latest/tryparse/deserializer/traits/struct

Provides methods for creating new `CoercionContext` instances. `new()` initializes with default settings and a maximum depth, while `with_max_depth()` allows for a custom limit.

```rust
pub fn new() -> Self

Creates a new coercion context with default settings.
Maximum depth is set to `DEFAULT_MAX_DEPTH`, matching BAML’s limit.
```

```rust
pub fn with_max_depth(max_depth: usize) -> Self

Creates a context with a custom maximum depth.
```

--------------------------------

### CoercionContext Methods

Source: https://docs.rs/tryparse/latest/tryparse/deserializer/traits/struct

Documentation for the public methods available on the CoercionContext struct, including creation, scope management, constraint handling, and transformation tracking.

```APIDOC
## Implementations: CoercionContext

### `pub fn new() -> Self`
Creates a new coercion context with default settings. Maximum depth is set to `DEFAULT_MAX_DEPTH`, matching BAML’s limit.

### `pub fn with_max_depth(max_depth: usize) -> Self`
Creates a context with a custom maximum depth.

### `pub fn enter_scope(&self, name: &str) -> Self`
Enters a new scope (e.g., entering a field). Returns a new context with the updated scope trail.

### `pub fn scope_path(&self) -> String`
Returns the current scope as a dotted path. Example: `<root>.user.address.street`

### `pub fn scope(&self) -> &[String]`
Returns a reference to the scope trail.

### `pub fn add_constraint(&mut self, result: ConstraintResult)`
Adds a constraint validation result. This allows tracking both @assert and @check constraints during deserialization.

### `pub fn constraints(&self) -> &ConstraintResults`
Returns all constraint validation results.

### `pub fn all_asserts_passed(&self) -> bool`
Returns true if all assert-level constraints passed. Check-level constraints do not affect this result.

### `pub fn failing_asserts(&self) -> Vec<&ConstraintResult>`
Returns all failing assert-level constraints.

### `pub fn add_transformation(&mut self, transformation: Transformation)`
Adds a transformation that occurred during deserialization. This allows tracking what modifications were made to the input data.

### `pub fn transformations(&self) -> &[Transformation]`
Returns all transformations applied during deserialization.

### `pub fn take_transformations(&mut self) -> Vec<Transformation>`
Takes all transformations, leaving an empty vector. This is useful for moving transformations into a FlexValue after deserialization.

### `pub fn check_can_enter_strict(&self, type_name: &str, value: &FlexValue) -> Result<()>`
Checks if we can enter a type for strict matching. Returns an error if this would exceed the depth limit or create a cycle.

### `pub fn with_visited_strict(&self, type_name: &str, value: &FlexValue) -> Self`
Creates a new context with the given type/value pair marked as visited (strict mode). This matches BAML’s approach of creating a new context instead of mutating.

### `pub fn check_can_enter_lenient(&self, type_name: &str, value: &FlexValue) -> Result<()>`
Checks if we can enter a type for lenient matching. Returns an error if this would exceed the depth limit or create a cycle.

### `pub fn with_visited_lenient(&self, type_name: &str, value: &FlexValue) -> Self`
Creates a new context with the given type/value pair marked as visited (lenient mode). This matches BAML’s approach of creating a new context instead of mutating.

### `pub const fn depth(&self) -> usize`
Returns the current depth.
```

--------------------------------

### Get Length of ConstraintResults in Rust

Source: https://docs.rs/tryparse/latest/src/tryparse/constraints

Returns the total number of ConstraintResult objects currently stored in the collection. This indicates how many constraints have been evaluated.

```rust
pub fn len(&self) -> usize {
    self.results.len()
}
```

--------------------------------

### Method: FlexValue::explanation_json

Source: https://docs.rs/tryparse/latest/tryparse/value/struct

Demonstrates how to generate a JSON representation of the FlexValue's transformation history and metadata using the `explanation_json` method. This is useful for understanding the parsing process and confidence score.

```rust
use tryparse::value::{FlexValue, Source, Transformation};
use serde_json::json;

let mut value = FlexValue::new(json!(42), Source::Direct);
value.add_transformation(Transformation::StringToNumber {
    original: "42".to_string(),
});

let explanation = value.explanation_json();
assert!(explanation["transformations"].is_array());
assert!(explanation["score"].is_number());
```

--------------------------------

### Get Check-Level Constraints in Rust

Source: https://docs.rs/tryparse/latest/src/tryparse/constraints

Retrieves all ConstraintResult objects for constraints that are classified as checks. This method filters the results based on the constraint type.

```rust
pub fn checks(&self) -> Vec<&ConstraintResult> {
    self.results
        .iter()
        .filter(|r| r.constraint.is_check())
        .collect()
}
```

--------------------------------

### Create Variant with Schema in Rust

Source: https://docs.rs/tryparse/latest/src/tryparse/schema

Demonstrates the creation of a Variant struct in Rust. It asserts that a new variant is correctly initialized with the provided name and schema.

```Rust
let variant = Variant::new("Active", Schema::Null);
assert_eq!(variant.name, "Active");
assert_eq!(variant.schema, Schema::Null);
```

--------------------------------

### Get Cleaner Name in Rust

Source: https://docs.rs/tryparse/latest/tryparse/parser/struct

Implementation of the `name` method from the `Cleaner` trait. Returns a static string representing the name of this cleaner, useful for debugging.

```rust
fn name(&self) -> &'static str
```

--------------------------------

### Create New YamlStrategy Instance - Rust

Source: https://docs.rs/tryparse/latest/tryparse/parser/strategies/struct

Provides a constructor function `new` for the YamlStrategy. This function is used to create a new instance of the strategy, ready for use in parsing operations.

```rust
pub fn new() -> Self {
    YamlStrategy
}
```

--------------------------------

### Rust: Consume FlexValue to get transformations

Source: https://docs.rs/tryparse/latest/src/tryparse/value

Consumes the `FlexValue` instance and returns its `transformations` vector. This is useful when the `FlexValue` is no longer needed and its transformation history needs to be extracted.

```rust
/// Consumes self and returns the transformations.
#[inline]
pub fn into_transformations(self) -> Vec<Transformation> {
    self.transformations
}
```

--------------------------------

### Rust: Get max transformation depth

Source: https://docs.rs/tryparse/latest/src/tryparse/value

Returns the maximum transformation depth recorded for this `FlexValue`. This is used in scoring to penalize transformations occurring at deeper nesting levels.

```rust
/// Returns the maximum transformation depth.
#[inline]
pub const fn max_transformation_depth(&self) -> usize {
    self.max_transformation_depth
}
```

--------------------------------

### Rust: Create new FlexValue instance

Source: https://docs.rs/tryparse/latest/src/tryparse/value

Provides a constructor `new` for creating a `FlexValue` with a given JSON value and source. It initializes transformations, confidence, and depth to default values.

```rust
/// Creates a new `FlexValue` with the given value and source.
///
/// # Examples
///
/// ```
/// use tryparse::value::{FlexValue, Source};
/// use serde_json::json;
///
/// let value = FlexValue::new(json!({"name": "Alice"}), Source::Direct);
/// assert_eq!(value.confidence(), 1.0);
/// ```
#[inline]
pub fn new(value: Value, source: Source) -> Self {
    Self {
        value,
        source,
        transformations: Vec::new(),
        confidence: 1.0,
        max_transformation_depth: 0,
    }
}
```

--------------------------------

### Get Failing Asserts in Rust

Source: https://docs.rs/tryparse/latest/src/tryparse/constraints

Collects and returns a vector of all ConstraintResult objects that represent failing asserts. This is useful for identifying specific validation failures.

```rust
pub fn failing_asserts(&self) -> Vec<&ConstraintResult> {
    self.results
        .iter()
        .filter(|r| r.is_failing_assert())
        .collect()
}
```

--------------------------------

### Rust: Unwrap Err - Panic on Ok Example

Source: https://docs.rs/tryparse/latest/tryparse/error/type

Illustrates `unwrap_err` panicking when called on a Result that is Ok, using the Ok value in the panic message.

```rust
let x: Result<u32, &str> = Ok(2);
x.unwrap_err(); // panics with `2`
```

--------------------------------

### Get Strategy Names - Rust

Source: https://docs.rs/tryparse/latest/src/tryparse/parser/mod

Returns a vector of static string slices containing the names of all registered strategies, in their priority order. It iterates over the `strategies` vector and maps each strategy to its name.

```rust
pub fn strategy_names(&self) -> Vec<&'static str> {
        self.strategies.iter().map(|s| s.name()).collect()
    }
```

--------------------------------

### Test: Parsing Markdown with Embedded JSON (Rust)

Source: https://docs.rs/tryparse/latest/src/tryparse/lib

This test case, `test_parse_markdown`, is intended to parse a multi-line string that includes markdown and an embedded JSON code block. The snippet shows the beginning of the input string preparation for this test.

```Rust
#[test]
fn test_parse_markdown() {
    let input = r#"
Here's the user:
```json

```

--------------------------------

### FlexibleParser Default Initialization (Rust)

Source: https://docs.rs/tryparse/latest/src/tryparse/parser/mod

Initializes a `FlexibleParser` with a default set of parsing strategies. These strategies are ordered by priority to optimize parsing efficiency. The default strategies include direct JSON, JSON fixing, raw primitives, state machines, heuristics, Markdown, and multiple objects. YAML parsing is included conditionally based on a feature flag.

```rust
pub fn new() -> Self {
        let mut strategies: Vec<Box<dyn ParsingStrategy>> = vec![
            Box::new(DirectJsonStrategy),
            Box::new(JsonFixerStrategy::default()),
            Box::new(RawPrimitiveStrategy::new()),
            Box::new(StateMachineStrategy::new()),
            Box::new(HeuristicStrategy::default()),
            Box::new(MarkdownStrategy::default()),
            Box::new(MultipleObjectsStrategy::new()),
        ];

        #[cfg(feature = "yaml")]
        {
            strategies.push(Box::new(YamlStrategy));
        }

        // Sort by priority
        strategies.sort_by_key(|s| s.priority());

        Self { strategies }
    }
```

--------------------------------

### Get YamlStrategy Priority - Rust

Source: https://docs.rs/tryparse/latest/tryparse/parser/strategies/struct

Implements the `priority` method from the `ParsingStrategy` trait. This method returns a `u8` value indicating the priority of this strategy relative to others.

```rust
fn priority(&self) -> u8 {
    // Define a priority value for the YAML strategy
    10
}
```

--------------------------------

### Result Implementations

Source: https://docs.rs/tryparse/latest/tryparse/error/type

Documentation for various implementations of the Result type, including methods for copying, cloning, transposing, flattening, and checking the status of Result values.

```APIDOC
## Implementations for Result<T, E>

### `impl<T, E> Result<&T, E>`

- **`fn copied(self) -> Result<T, E>` where `T: Copy`**
  Maps a `Result<&T, E>` to a `Result<T, E>` by copying the contents of the `Ok` part.
  #### Examples
  ```rust
  let val = 12;
  let x: Result<&i32, i32> = Ok(&val);
  assert_eq!(x, Ok(&12));
  let copied = x.copied();
  assert_eq!(copied, Ok(12));
  ```

- **`fn cloned(self) -> Result<T, E>` where `T: Clone`**
  Maps a `Result<&T, E>` to a `Result<T, E>` by cloning the contents of the `Ok` part.
  #### Examples
  ```rust
  let val = 12;
  let x: Result<&i32, i32> = Ok(&val);
  assert_eq!(x, Ok(&12));
  let cloned = x.cloned();
  assert_eq!(cloned, Ok(12));
  ```

### `impl<T, E> Result<&mut T, E>`

- **`fn copied(self) -> Result<T, E>` where `T: Copy`**
  Maps a `Result<&mut T, E>` to a `Result<T, E>` by copying the contents of the `Ok` part.
  #### Examples
  ```rust
  let mut val = 12;
  let x: Result<&mut i32, i32> = Ok(&mut val);
  assert_eq!(x, Ok(&mut 12));
  let copied = x.copied();
  assert_eq!(copied, Ok(12));
  ```

- **`fn cloned(self) -> Result<T, E>` where `T: Clone`**
  Maps a `Result<&mut T, E>` to a `Result<T, E>` by cloning the contents of the `Ok` part.
  #### Examples
  ```rust
  let mut val = 12;
  let x: Result<&mut i32, i32> = Ok(&mut val);
  assert_eq!(x, Ok(&mut 12));
  let cloned = x.cloned();
  assert_eq!(cloned, Ok(12));
  ```

### `impl<T, E> Result<Option<T>, E>`

- **`fn transpose(self) -> Option<Result<T, E>>`**
  Transposes a `Result` of an `Option` into an `Option` of a `Result`.
  `Ok(None)` will be mapped to `None`. `Ok(Some(_))` and `Err(_)` will be mapped to `Some(Ok(_))` and `Some(Err(_))`. 
  #### Examples
  ```rust
  #[derive(Debug, Eq, PartialEq)]
  struct SomeErr;

  let x: Result<Option<i32>, SomeErr> = Ok(Some(5));
  let y: Option<Result<i32, SomeErr>> = Some(Ok(5));
  assert_eq!(x.transpose(), y);
  ```

### `impl<T, E> Result<Result<T, E>, E>`

- **`fn flatten(self) -> Result<T, E>`**
  Converts from `Result<Result<T, E>, E>` to `Result<T, E>`.
  #### Examples
  ```rust
  let x: Result<Result<&'static str, u32>, u32> = Ok(Ok("hello"));
  assert_eq!(Ok("hello"), x.flatten());

  let x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));
  assert_eq!(Err(6), x.flatten());

  let x: Result<Result<&'static str, u32>, u32> = Err(6);
  assert_eq!(Err(6), x.flatten());
  ```
  Flattening only removes one level of nesting at a time:
  ```rust
  let x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok("hello")));
  assert_eq!(Ok(Ok("hello")), x.flatten());
  assert_eq!(Ok("hello"), x.flatten().flatten());
  ```

### `impl<T, E> Result<T, E>`

- **`fn is_ok(&self) -> bool`**
  Returns `true` if the result is `Ok`.
  #### Examples
  ```rust
  let x: Result<i32, &str> = Ok(-3);
  assert_eq!(x.is_ok(), true);

  let x: Result<i32, &str> = Err("Some error message");
  assert_eq!(x.is_ok(), false);
  ```

- **`fn is_ok_and<F>(self, f: F) -> bool` where `F: FnOnce(T) -> bool`**
  Returns `true` if the result is `Ok` and the value inside of it matches a predicate.
  #### Examples
  ```rust
  let x: Result<u32, &str> = Ok(2);
  assert_eq!(x.is_ok_and(|x| x > 1), true);

  let x: Result<u32, &str> = Ok(0);
  assert_eq!(x.is_ok_and(|x| x > 1), false);

  let x: Result<u32, &str> = Err("hey");
  assert_eq!(x.is_ok_and(|x| x > 1), false);

  let x: Result<String, &str> = Ok("ownership".to_string());
  assert_eq!(x.as_ref().is_ok_and(|x| x.len() > 1), true);
  println!("still alive {:?}", x);
  ```

- **`fn is_err(&self) -> bool`**
  Returns `true` if the result is `Err`.
  #### Examples
  ```rust
  let x: Result<i32, &str> = Ok(-3);
  assert_eq!(x.is_err(), false);

  let x: Result<i32, &str> = Err("Some error message");
  assert_eq!(x.is_err(), true);
  ```

- **`fn is_err_and<F>(self, f: F) -> bool` where `F: FnOnce(E) -> bool`**
  Returns `true` if the result is `Err` and the value inside of it matches a predicate.

```

--------------------------------

### Rust: Score Markdown Code Blocks with Keyword Analysis

Source: https://docs.rs/tryparse/latest/src/tryparse/parser/strategies/markdown

This Rust code snippet defines a scoring mechanism for markdown code blocks based on positive and negative keywords present in the content. It also incorporates positional and field count scoring to determine the relevance and completeness of the data. Dependencies include the `context` string and `score` integer. Outputs a calculated score.

```rust
            let positive_keywords = [
                ("real", 20),
                ("actual", 20),
                ("result", 15),
                ("answer", 15),
                ("final", 15),
                ("correct", 15),
                ("here is", 10),
                ("here's", 10),
                ("output", 10),
                ("response", 8),
            ];

            for (keyword, points) in &positive_keywords {
                if context.contains(keyword) {
                    score += points;
                }
            }

            // Negative indicators (this is an example/demo)
            let negative_keywords = [
                ("example", -25),
                ("sample", -20),
                ("demo", -20),
                ("test", -15),
                ("illustration", -15),
                ("for instance", -15),
                ("like this", -10),
                ("such as", -10),
            ];

            for (keyword, points) in &negative_keywords {
                if context.contains(keyword) {
                    score += points;
                }
            }
        }

        // Position-based scoring: later blocks often more important
        // (after examples comes the real data)
        if total_blocks > 1 {
            let position_score = (block_index * 30) / (total_blocks - 1);
            score += position_score as i32;
        }

        // Size-based scoring: larger objects might be more complete
        let field_count = block_content.matches(':').count();
        if field_count > 5 {
            score += 10;
        } else if field_count > 10 {
            score += 20;
        }

        score
    }
}

```

--------------------------------

### Get YamlStrategy Name - Rust

Source: https://docs.rs/tryparse/latest/tryparse/parser/strategies/struct

Implements the `name` method from the `ParsingStrategy` trait for YamlStrategy. This method returns a static string representing the name of the strategy, useful for debugging.

```rust
fn name(&self) -> &'static str {
    "yaml"
}
```

--------------------------------

### Test New Parser Initialization - Rust

Source: https://docs.rs/tryparse/latest/src/tryparse/parser/mod

Tests the initialization of a new `FlexibleParser` instance. It checks the total number of strategies, accounting for the optional `yaml` feature. This test ensures that the parser is created with the expected number of active strategies.

```rust
#[test]
    fn test_new_parser() {
        let parser = FlexibleParser::new();

        // Markdown and MultipleObjects are always enabled, YAML is optional
        #[cfg(feature = "yaml")]
        assert_eq!(parser.strategy_count(), 8);

        #[cfg(not(feature = "yaml"))]
        assert_eq!(parser.strategy_count(), 7);
    }
```

--------------------------------

### Rust: Test Candidate Ranking Logic

Source: https://docs.rs/tryparse/latest/src/tryparse/scoring

These tests ensure that the `rank_candidates` function correctly orders a list of `FlexValue` candidates based on their scores. The tests verify that direct sources are prioritized, followed by markdown, and then fixed JSON sources.

```rust
#[cfg(test)]
mod tests {
    use serde_json::json;

    use super::*;
    use crate::value::{JsonFix, Transformation};

    #[test]
    fn test_rank_candidates() {
        let candidates = vec![
            FlexValue::from_fixed_json(json!(1), vec![JsonFix::TrailingCommas]),
            FlexValue::new(json!(2), Source::Direct),
            FlexValue::new(json!(3), Source::Markdown { lang: None }),
        ];

        let ranked = rank_candidates(candidates);

        // Direct should be first
        assert_eq!(ranked[0].value, json!(2));
        // Markdown should be second
        assert_eq!(ranked[1].value, json!(3));
        // Fixed should be last
        assert_eq!(ranked[2].value, json!(1));
    }

    #[test]
    fn test_rank_preserves_all_candidates() {
        let candidates = vec![
            FlexValue::new(json!(1), Source::Direct),
            FlexValue::new(json!(2), Source::Direct),
            FlexValue::new(json!(3), Source::Direct),
        ];

        let count = candidates.len();
        let ranked = rank_candidates(candidates);

        assert_eq!(ranked.len(), count);
    }
}
```

--------------------------------

### Get the Best Candidate from a List (Rust)

Source: https://docs.rs/tryparse/latest/src/tryparse/scoring

Returns the best FlexValue candidate (the one with the lowest score) from a given vector. If the input vector is empty, it returns None. This function also consumes the input vector.

```rust
pub fn best_candidate(candidates: Vec<FlexValue>) -> Option<FlexValue> {
    if candidates.is_empty() {
        return None;
    }
    
    // For simplicity, directly use the ranked list to find the best.
    // In a real scenario, you might want to sort and then take the first element.
    // However, as rank_candidates is available, we can infer its behavior.
    // For this example, let's assume a direct sort and take operation if not using rank_candidates directly.
    // If rank_candidates is always used before, this function could just call it and return the first.
    // For a standalone function, it would look like this:
    let mut sorted_candidates = candidates;
    sorted_candidates.sort_by_cached_key(score_candidate);
    sorted_candidates.into_iter().next()
}
```

--------------------------------

### Rust: Implement StateMachineStrategy for JSON Parsing

Source: https://docs.rs/tryparse/latest/src/tryparse/parser/strategies/state_machine_strategy

This Rust code implements the `StateMachineStrategy` for parsing JSON. It leverages a `StateMachineParser` to handle malformed JSON, unclosed collections, and multiple top-level objects, offering a more robust parsing approach than regex-based methods. Dependencies include `super::ParsingStrategy`, `crate::error::Result`, `crate::parser::state_machine::StateMachineParser`, and `crate::value::FlexValue`.

```rust
use super::ParsingStrategy;
use crate::{error::Result, parser::state_machine::StateMachineParser, value::FlexValue};

/// Strategy that uses the state machine parser for robust JSON parsing.
///
/// This strategy is particularly effective at:
/// - Handling unclosed collections (auto-closes)
/// - Parsing multiple top-level JSON objects
/// - Context-aware string handling
/// - Maintaining parse state through nested structures
#[derive(Debug, Clone)]
pub struct StateMachineStrategy {
    parser: StateMachineParser,
}

impl Default for StateMachineStrategy {
    fn default() -> Self {
        Self::new()
    }
}

impl StateMachineStrategy {
    /// Creates a new state machine strategy.
    pub fn new() -> Self {
        Self {
            parser: StateMachineParser::new(),
        }
    }
}

impl ParsingStrategy for StateMachineStrategy {
    fn name(&self) -> &'static str {
        "state_machine"
    }

    fn priority(&self) -> u8 {
        // Priority 15: After direct JSON (1) and JSON fixer (10),
        // but before heuristic (20)
        15
    }

    fn parse(&self, input: &str) -> Result<Vec<FlexValue>> {
        let mut parser = self.parser.clone();
        parser.parse(input)
    }
}
```

--------------------------------

### CoercingDeserializer Example: String to u32 Coercion

Source: https://docs.rs/tryparse/latest/src/tryparse/deserializer/mod

Demonstrates how `CoercingDeserializer` can coerce a JSON string value to a `u32` field during deserialization. It wraps a `FlexValue` and implements `serde::Deserializer`, enabling smart type conversions.

```rust
use tryparse::deserializer::CoercingDeserializer;
use tryparse::value::{FlexValue, Source};
use serde::Deserialize;
use serde_json::json;

#[derive(Deserialize, Debug, PartialEq)]
struct User {
    name: String,
    age: u32,
}

let value = FlexValue::new(
    json!({"name": "Alice", "age": "30"}),
    Source::Direct
);
let mut deserializer = CoercingDeserializer::new(value);
let user = User::deserialize(&mut deserializer).unwrap();
assert_eq!(user.age, 30); // String "30" coerced to u32
```

--------------------------------

### Debug Implementation for Transformation

Source: https://docs.rs/tryparse/latest/tryparse/value/enum

Enables the debugging of Transformation structs by implementing the fmt method. This allows Transformation instances to be formatted for display in debugging contexts.

```rust
impl Debug for Transformation {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        // ... implementation details ...
    }
}
```

--------------------------------

### Constructor: FlexValue::new

Source: https://docs.rs/tryparse/latest/tryparse/value/struct

Example of creating a new FlexValue instance using the associated function `new`. This function takes a JSON value and a Source enum variant, initializing the FlexValue with a default confidence score.

```rust
use tryparse::value::{FlexValue, Source};
use serde_json::json;

let value = FlexValue::new(json!({"name": "Alice"}), Source::Direct);
assert_eq!(value.confidence(), 1.0);
```

--------------------------------

### Rust: Test DirectJsonStrategy Priority and Name

Source: https://docs.rs/tryparse/latest/src/tryparse/parser/strategies/mod

Provides unit tests for the `DirectJsonStrategy` in Rust. It verifies that the strategy has the correct priority (1) and returns the expected name ('direct_json'). These tests ensure the basic functionality of a specific parsing strategy.

```rust
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_direct_json_priority() {
        let strategy = DirectJsonStrategy;
        assert_eq!(strategy.priority(), 1);
    }

    #[test]
    fn test_strategy_name() {
        let strategy = DirectJsonStrategy;
        assert_eq!(strategy.name(), "direct_json");
    }
}
```

--------------------------------

### Rust: Result::is_err_and Method Example

Source: https://docs.rs/tryparse/latest/tryparse/error/type

Shows the `is_err_and` method for `Result<E, T>`, which checks if the `Result` is `Err` and its contained error value satisfies a given predicate function. This enables conditional checks on the error value.

```rust
let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_err_and(|e| e.len() > 5), true);

let x: Result<i32, &str> = Err("hi");
assert_eq!(x.is_err_and(|e| e.len() > 5), false);

let x: Result<i32, &str> = Ok(10);
assert_eq!(x.is_err_and(|e| e.len() > 5), false);

```
Tokens:
Raw