vidya 1.6.0

Vidya — programming reference library and queryable corpus for AGNOS
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

//! Side-by-side cross-language comparison.

use crate::error::Result;
use crate::language::Language;
use crate::registry::Registry;
use serde::{Deserialize, Serialize};

/// A side-by-side comparison of a concept across languages.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Comparison {
    /// The concept ID.
    pub concept_id: String,
    /// The concept title.
    pub concept_title: String,
    /// Implementations, one per requested language (in order).
    pub implementations: Vec<ComparedExample>,
}

/// One language's implementation in a comparison.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ComparedExample {
    /// The programming language of this implementation.
    pub language: Language,
    /// The source code of the example.
    pub code: String,
    /// Human-readable explanation of the approach.
    pub explanation: String,
}

/// Compare a concept across multiple languages.
///
/// Returns implementations for all requested languages that have examples.
/// Languages without implementations are silently skipped.
pub fn compare(
    registry: &Registry,
    concept_id: &str,
    languages: &[Language],
) -> Result<Comparison> {
    let concept = registry.get_or_err(concept_id)?;

    let implementations: Vec<ComparedExample> = languages
        .iter()
        .filter_map(|lang| {
            concept.example(*lang).map(|ex| ComparedExample {
                language: *lang,
                code: ex.code.clone(),
                explanation: ex.explanation.clone(),
            })
        })
        .collect();

    Ok(Comparison {
        concept_id: concept.id.clone(),
        concept_title: concept.title.clone(),
        implementations,
    })
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::concept::{Concept, Example, Topic};
    use std::collections::HashMap;

    fn make_registry() -> Registry {
        let mut reg = Registry::new();
        let mut ex = HashMap::new();
        ex.insert(
            Language::Rust,
            Example {
                language: Language::Rust,
                code: "let s = String::from(\"hello\");".into(),
                explanation: "Owned string".into(),
                source_path: None,
            },
        );
        ex.insert(
            Language::Python,
            Example {
                language: Language::Python,
                code: "s = \"hello\"".into(),
                explanation: "Python string".into(),
                source_path: None,
            },
        );
        reg.register(Concept {
            id: "strings".into(),
            title: "String Basics".into(),
            topic: Topic::DataTypes,
            description: "Basic string operations.".into(),
            best_practices: vec![],
            gotchas: vec![],
            performance_notes: vec![],
            tags: vec![],
            examples: ex,
        });
        reg
    }

    #[test]
    fn compare_two_languages() {
        let reg = make_registry();
        let cmp = compare(&reg, "strings", &[Language::Rust, Language::Python]).unwrap();
        assert_eq!(cmp.implementations.len(), 2);
        assert_eq!(cmp.implementations[0].language, Language::Rust);
        assert_eq!(cmp.implementations[1].language, Language::Python);
    }

    #[test]
    fn compare_skips_missing() {
        let reg = make_registry();
        let cmp = compare(&reg, "strings", &[Language::Rust, Language::C]).unwrap();
        assert_eq!(cmp.implementations.len(), 1);
    }

    #[test]
    fn compare_concept_not_found() {
        let reg = make_registry();
        assert!(compare(&reg, "missing", &[Language::Rust]).is_err());
    }
}