Struct Example 

pub struct Example {
    pub data: HashMap<String, Value>,
    pub input_keys: Vec<String>,
    pub output_keys: Vec<String>,
}

Fields

data: HashMap<String, Value>

input_keys: Vec<String>

output_keys: Vec<String>

Implementations

impl Example

pub fn new( data: HashMap<String, Value>, input_keys: Vec<String>, output_keys: Vec<String>, ) -> Self

Examples found in repository

examples/02-module-iteration-and-updation.rs (lines 72-79)

    async fn forward(&self, inputs: Example) -> Result<Prediction> {
        let answerer_prediction = self.answerer.forward(inputs.clone()).await?;

        let question = inputs.data.get("question").unwrap().clone();
        let answer = answerer_prediction.data.get("answer").unwrap().clone();

        let inputs = Example::new(
            hashmap! {
                "answer".to_string() => answer.clone(),
                "question".to_string() => question.clone()
            },
            vec!["answer".to_string(), "question".to_string()],
            vec![],
        );
        let rating_prediction = self.rater.forward(inputs).await?;
        Ok(prediction! {
            "answer"=> answer,
            "question"=> question,
            "rating"=> rating_prediction.data.get("rating").unwrap().clone(),
        }
        .set_lm_usage(rating_prediction.lm_usage))
    }

examples/06-other-providers-batch.rs (lines 56-63)

    async fn forward(&self, inputs: Example) -> Result<Prediction> {
        let answerer_prediction = self.answerer.forward(inputs.clone()).await?;

        let question = inputs.data.get("question").unwrap().clone();
        let answer = answerer_prediction.data.get("answer").unwrap().clone();
        let answer_lm_usage = answerer_prediction.lm_usage;

        let inputs = Example::new(
            hashmap! {
                "answer".to_string() => answer.clone(),
                "question".to_string() => question.clone()
            },
            vec!["answer".to_string(), "question".to_string()],
            vec![],
        );
        let rating_prediction = self.rater.forward(inputs).await?;
        let rating_lm_usage = rating_prediction.lm_usage;

        Ok(prediction! {
            "answer"=> answer,
            "question"=> question,
            "rating"=> rating_prediction.data.get("rating").unwrap().clone(),
        }
        .set_lm_usage(answer_lm_usage + rating_lm_usage))
    }

pub fn get(&self, key: &str, default: Option<&str>) -> Value

Examples found in repository

examples/09-gepa-sentiment.rs (line 60)

    async fn feedback_metric(&self, example: &Example, prediction: &Prediction) -> FeedbackMetric {
        let predicted = prediction
            .get("sentiment", None)
            .as_str()
            .unwrap_or("")
            .to_string()
            .to_lowercase();

        let expected = example
            .get("expected_sentiment", None)
            .as_str()
            .unwrap_or("")
            .to_string()
            .to_lowercase();

        let text = example.get("text", None).as_str().unwrap_or("").to_string();

        let reasoning = prediction
            .get("reasoning", None)
            .as_str()
            .unwrap_or("")
            .to_string();

        // Calculate score
        let correct = predicted == expected;
        let score = if correct { 1.0 } else { 0.0 };

        // Create rich feedback
        let mut feedback = if correct {
            format!("Correct classification: \"{}\"\n", expected)
        } else {
            format!(
                "Incorrect classification\n  Expected: \"{}\"\n  Predicted: \"{}\"\n",
                expected, predicted
            )
        };

        // Add context about the input
        feedback.push_str(&format!("  Input text: \"{}\"\n", text));

        // Add reasoning analysis
        if !reasoning.is_empty() {
            feedback.push_str(&format!("  Reasoning: {}\n", reasoning));

            // Check if reasoning mentions key sentiment words
            let has_reasoning_quality = if correct {
                // For correct answers, check if reasoning is substantive
                reasoning.len() > 20
            } else {
                // For incorrect answers, note what went wrong
                false
            };

            if has_reasoning_quality {
                feedback.push_str("  Reasoning appears detailed\n");
            } else if !correct {
                feedback.push_str("  May have misunderstood the text sentiment\n");
            }
        }

        FeedbackMetric::new(score, feedback)
    }

examples/10-gepa-llm-judge.rs (line 105)

    async fn feedback_metric(&self, example: &Example, prediction: &Prediction) -> FeedbackMetric {
        // Extract the problem and answers
        let problem = example
            .get("problem", None)
            .as_str()
            .unwrap_or("")
            .to_string();

        let expected = example
            .get("expected_answer", None)
            .as_str()
            .unwrap_or("")
            .to_string();

        let student_answer = prediction
            .get("answer", None)
            .as_str()
            .unwrap_or("")
            .to_string();

        let student_reasoning = prediction
            .get("reasoning", None)
            .as_str()
            .unwrap_or("No reasoning provided")
            .to_string();

        // Quick check: is the answer exactly correct?
        let answer_matches = student_answer.trim() == expected.trim();

        // Use LLM judge to analyze the reasoning quality
        // This is where the magic happens - the judge provides rich feedback
        let judge_input = example! {
            "problem": "input" => &problem,
            "expected_answer": "input" => &expected,
            "student_answer": "input" => &student_answer,
            "student_reasoning": "input" => &student_reasoning
        };

        let judge_output = match self
            .judge
            .forward_with_config(judge_input, Arc::clone(&self.judge_lm))
            .await
        {
            Ok(output) => output,
            Err(_) => {
                // If judge fails, fall back to simple feedback
                let score = if answer_matches { 1.0 } else { 0.0 };
                let simple_feedback = format!(
                    "Problem: {}\nExpected: {}\nPredicted: {}\nAnswer: {}",
                    problem,
                    expected,
                    student_answer,
                    if answer_matches {
                        "CORRECT"
                    } else {
                        "INCORRECT"
                    }
                );
                return FeedbackMetric::new(score, simple_feedback);
            }
        };

        let judge_evaluation = judge_output
            .get("evaluation", None)
            .as_str()
            .unwrap_or("Unable to evaluate")
            .to_string();

        // Calculate score based on answer correctness and reasoning quality
        // The judge's evaluation helps us assign partial credit
        let score = if answer_matches {
            // Correct answer - check if reasoning is also sound
            if judge_evaluation.to_lowercase().contains("sound reasoning")
                || judge_evaluation.to_lowercase().contains("correct approach")
            {
                1.0 // Perfect: right answer, good reasoning
            } else {
                0.7 // Right answer but flawed reasoning (lucky guess?)
            }
        } else {
            // Wrong answer - check if there's any partial credit
            if judge_evaluation.to_lowercase().contains("correct approach")
                || judge_evaluation.to_lowercase().contains("good start")
            {
                0.3 // Wrong answer but some valid steps
            } else {
                0.0 // Completely wrong
            }
        };

        // Construct rich textual feedback
        // This combines factual info with the judge's analysis
        let mut feedback = String::new();

        feedback.push_str(&format!("Problem: {}\n", problem));
        feedback.push_str(&format!("Expected: {}\n", expected));
        feedback.push_str(&format!("Predicted: {}\n", student_answer));

        if answer_matches {
            feedback.push_str("Answer: CORRECT\n\n");
        } else {
            feedback.push_str("Answer: INCORRECT\n\n");
        }

        feedback.push_str("Reasoning Quality Analysis:\n");
        feedback.push_str(&judge_evaluation);

        // Return the feedback metric with score and rich text
        FeedbackMetric::new(score, feedback)
    }

pub fn keys(&self) -> Vec<String>

pub fn values(&self) -> Vec<Value>

pub fn set_input_keys(&mut self, keys: Vec<String>)

pub fn with_input_keys(&self, keys: Vec<String>) -> Self

pub fn without(&self, keys: Vec<String>) -> Self

Trait Implementations

impl Clone for Example

fn clone(&self) -> Example

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Example

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

Formats the value using the given formatter.

impl Default for Example

fn default() -> Example

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Example

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Index<String> for Example

type Output = Value

The returned type after indexing.

fn index(&self, index: String) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IntoIterator for Example

type Item = (String, Value)

The type of the elements being iterated over.

type IntoIter = IntoIter<String, Value>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl Serialize for Example

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

where __S: Serializer,

Serialize this value into the given Serde serializer.