Struct Language 

pub struct Language {
    pub id: String,
    pub genome: LinguisticGenome,
    /* private fields */
}

A complete language with its genome and optional caching.

Fields

id: String

Unique identifier for this language

genome: LinguisticGenome

The linguistic genome (complete language specification)

Implementations

impl Language

pub fn from_culture( culture: CulturalProfile, geography: Geography, seed: u64, ) -> Self

Create a new language from a cultural profile and geography.

Arguments

• culture - The cultural personality profile
• geography - The geographic environment
• seed - Seed for deterministic generation

Example

use phyla_lang::{Language, CulturalProfile, Geography};

let culture = CulturalProfile::new(4.0, 3.0, 2.0, 3.0, 3.0, 4.0);
let language = Language::from_culture(culture, Geography::Coastal, 12345);

Examples found in repository

examples/compare_with_js.rs (line 90)

fn create_melodic_coastal() -> Language {
    // Based on JavaScript: agreeableness: 4, openness: 3, conscientiousness: 2
    let culture = CulturalProfile::new(
        4.0, // agreeableness
        3.0, // openness
        2.0, // conscientiousness
        3.0, // extraversion
        3.0, // honesty_humility
        4.0, // emotionality (high for emotional culture)
    );

    Language::from_culture(culture, Geography::Coastal, 1001)
}

fn create_mountain_warriors() -> Language {
    // Based on JavaScript: agreeableness: 1, openness: 2, conscientiousness: 4
    let culture = CulturalProfile::new(
        1.0, // agreeableness (disagreeable)
        2.0, // openness
        4.0, // conscientiousness
        4.0, // extraversion (brave, assertive)
        3.0, // honesty_humility
        2.0, // emotionality (stoic)
    );

    Language::from_culture(culture, Geography::Mountains, 1002)
}

fn create_river_scholars() -> Language {
    // Based on JavaScript: agreeableness: 3, openness: 4, conscientiousness: 4
    let culture = CulturalProfile::new(
        3.0, // agreeableness
        4.0, // openness (intellectual, creative)
        4.0, // conscientiousness (organized, precise)
        3.0, // extraversion
        4.0, // honesty_humility (modest scholars)
        3.0, // emotionality
    );

    Language::from_culture(culture, Geography::RiverValley, 1003)
}

fn create_desert_nomads() -> Language {
    // Based on JavaScript: agreeableness: 2, openness: 2, conscientiousness: 3
    let culture = CulturalProfile::new(
        2.0, // agreeableness (independent)
        2.0, // openness (traditional)
        3.0, // conscientiousness
        3.0, // extraversion
        3.0, // honesty_humility
        2.0, // emotionality (hardy, resilient)
    );

    Language::from_culture(culture, Geography::Desert, 1004)
}

examples/basic_usage.rs (line 37)

fn main() {
    println!("=== Phyla-Lang: Procedural Language Generation ===\n");

    // Define different cultures
    let coastal_folk = CulturalProfile::new(
        4.0, // High agreeableness - cooperative, empathetic
        3.0, // Moderate openness
        2.0, // Lower conscientiousness - more flexible
        3.0, // Moderate extraversion
        3.0, // Moderate honesty-humility
        4.0, // High emotionality - sensitive, expressive
    );

    let mountain_warriors = CulturalProfile::new(
        1.0, // Low agreeableness - more competitive
        2.0, // Lower openness - traditional
        4.0, // High conscientiousness - disciplined
        3.0, // Moderate extraversion
        3.0, // Moderate honesty-humility
        2.0, // Lower emotionality - stoic
    );

    let river_scholars = CulturalProfile::new(
        3.0, // Moderate agreeableness
        4.0, // High openness - innovative, curious
        4.0, // High conscientiousness - organized
        3.0, // Moderate extraversion
        4.0, // High honesty-humility - modest, sincere
        3.0, // Moderate emotionality
    );

    // Create languages
    let melodic = Language::from_culture(coastal_folk, Geography::Coastal, 1001);
    let harsh = Language::from_culture(mountain_warriors, Geography::Mountains, 1002);
    let scholarly = Language::from_culture(river_scholars, Geography::RiverValley, 1003);

    println!("1. MELODIC COASTAL LANGUAGE (Agreeable, Emotional, Coastal)");
    println!("   Word order: {:?}", melodic.word_order());
    demonstrate_language(&melodic);

    println!("\n2. MOUNTAIN WARRIOR LANGUAGE (Disagreeable, Conscientious, Mountains)");
    println!("   Word order: {:?}", harsh.word_order());
    demonstrate_language(&harsh);

    println!("\n3. RIVER VALLEY SCHOLAR LANGUAGE (Open, Conscientious, River Valley)");
    println!("   Word order: {:?}", scholarly.word_order());
    demonstrate_language(&scholarly);

    // Demonstrate determinism
    println!("\n=== DETERMINISM DEMONSTRATION ===");
    println!("Creating two identical languages with the same parameters...\n");

    let lang1 = Language::from_culture(coastal_folk, Geography::Coastal, 5555);
    let lang2 = Language::from_culture(coastal_folk, Geography::Coastal, 5555);

    let word1 = lang1.translate_word("forever");
    let word2 = lang2.translate_word("forever");

    println!("Language 1 translates 'forever' as: {}", word1);
    println!("Language 2 translates 'forever' as: {}", word2);
    println!("Are they the same? {}", word1 == word2);

    // Demonstrate word variation
    println!("\n=== VOCABULARY SAMPLE ===");
    let concepts = vec![
        "water", "fire", "earth", "wind", "sun", "moon", "star", "tree", "stone", "mountain",
    ];

    println!("\nCoastal Language:");
    for concept in &concepts {
        println!("  {} → {}", concept, melodic.translate_word(concept));
    }

    println!("\nMountain Language:");
    for concept in &concepts {
        println!("  {} → {}", concept, harsh.translate_word(concept));
    }

    println!("\nScholar Language:");
    for concept in &concepts {
        println!("  {} → {}", concept, scholarly.translate_word(concept));
    }
}

pub fn from_genome(genome: LinguisticGenome) -> Self

Create a language directly from a genome.

pub fn translate_word(&self, concept: &str) -> String

Translate a single word/concept to this language.

Example

use phyla_lang::{Language, CulturalProfile, Geography};

let culture = CulturalProfile::new(4.0, 3.0, 2.0, 3.0, 3.0, 4.0);
let language = Language::from_culture(culture, Geography::Coastal, 12345);

let word = language.translate_word("house");
// The same input always produces the same output
assert_eq!(word, language.translate_word("house"));

Examples found in repository

examples/compare_with_js.rs (line 57)

fn main() {
    println!("=== Comparing Rust Implementation with JavaScript Demo ===\n");

    // Recreate the cultures from language_generator.html
    let melodic = create_melodic_coastal();
    let martial = create_mountain_warriors();
    let scholarly = create_river_scholars();
    let desert = create_desert_nomads();

    // Test phrase from the JavaScript demo
    let test_phrase = "I bring the beer quickly";

    println!("Translating: \"{}\"\n", test_phrase);

    println!("1. Melodic Coastal Folk (Agreeable, Emotional, Open)");
    println!("   Geography: Coastal plains");
    println!("   Word Order: {:?}", melodic.word_order());
    println!("   Translation: \"{}\"", melodic.translate_phrase(test_phrase));
    println!();

    println!("2. Mountain Warriors (Disagreeable, Conscientious, Brave)");
    println!("   Geography: Mountains");
    println!("   Word Order: {:?}", martial.word_order());
    println!("   Translation: \"{}\"", martial.translate_phrase(test_phrase));
    println!();

    println!("3. River Valley Scholars (Open, Conscientious, Intellectual)");
    println!("   Geography: River valleys");
    println!("   Word Order: {:?}", scholarly.word_order());
    println!("   Translation: \"{}\"", scholarly.translate_phrase(test_phrase));
    println!();

    println!("4. Desert Nomads (Independent, Hardy, Traditional)");
    println!("   Geography: Arid deserts");
    println!("   Word Order: {:?}", desert.word_order());
    println!("   Translation: \"{}\"", desert.translate_phrase(test_phrase));
    println!();

    // Demonstrate individual word translations
    println!("=== Individual Word Translations ===\n");

    let words = ["water", "sun", "mountain", "warrior", "peace"];

    for word in &words {
        println!("{:12} → Coastal: {:12} | Mountain: {:12} | Scholar: {:12} | Desert: {:12}",
            word,
            melodic.translate_word(word),
            martial.translate_word(word),
            scholarly.translate_word(word),
            desert.translate_word(word),
        );
    }

    println!("\n=== Phonological Characteristics ===\n");

    println!("Melodic Coastal Folk:");
    print_phonology(&melodic);

    println!("\nMountain Warriors:");
    print_phonology(&martial);

    println!("\nRiver Valley Scholars:");
    print_phonology(&scholarly);

    println!("\nDesert Nomads:");
    print_phonology(&desert);
}

examples/basic_usage.rs (line 60)

fn main() {
    println!("=== Phyla-Lang: Procedural Language Generation ===\n");

    // Define different cultures
    let coastal_folk = CulturalProfile::new(
        4.0, // High agreeableness - cooperative, empathetic
        3.0, // Moderate openness
        2.0, // Lower conscientiousness - more flexible
        3.0, // Moderate extraversion
        3.0, // Moderate honesty-humility
        4.0, // High emotionality - sensitive, expressive
    );

    let mountain_warriors = CulturalProfile::new(
        1.0, // Low agreeableness - more competitive
        2.0, // Lower openness - traditional
        4.0, // High conscientiousness - disciplined
        3.0, // Moderate extraversion
        3.0, // Moderate honesty-humility
        2.0, // Lower emotionality - stoic
    );

    let river_scholars = CulturalProfile::new(
        3.0, // Moderate agreeableness
        4.0, // High openness - innovative, curious
        4.0, // High conscientiousness - organized
        3.0, // Moderate extraversion
        4.0, // High honesty-humility - modest, sincere
        3.0, // Moderate emotionality
    );

    // Create languages
    let melodic = Language::from_culture(coastal_folk, Geography::Coastal, 1001);
    let harsh = Language::from_culture(mountain_warriors, Geography::Mountains, 1002);
    let scholarly = Language::from_culture(river_scholars, Geography::RiverValley, 1003);

    println!("1. MELODIC COASTAL LANGUAGE (Agreeable, Emotional, Coastal)");
    println!("   Word order: {:?}", melodic.word_order());
    demonstrate_language(&melodic);

    println!("\n2. MOUNTAIN WARRIOR LANGUAGE (Disagreeable, Conscientious, Mountains)");
    println!("   Word order: {:?}", harsh.word_order());
    demonstrate_language(&harsh);

    println!("\n3. RIVER VALLEY SCHOLAR LANGUAGE (Open, Conscientious, River Valley)");
    println!("   Word order: {:?}", scholarly.word_order());
    demonstrate_language(&scholarly);

    // Demonstrate determinism
    println!("\n=== DETERMINISM DEMONSTRATION ===");
    println!("Creating two identical languages with the same parameters...\n");

    let lang1 = Language::from_culture(coastal_folk, Geography::Coastal, 5555);
    let lang2 = Language::from_culture(coastal_folk, Geography::Coastal, 5555);

    let word1 = lang1.translate_word("forever");
    let word2 = lang2.translate_word("forever");

    println!("Language 1 translates 'forever' as: {}", word1);
    println!("Language 2 translates 'forever' as: {}", word2);
    println!("Are they the same? {}", word1 == word2);

    // Demonstrate word variation
    println!("\n=== VOCABULARY SAMPLE ===");
    let concepts = vec![
        "water", "fire", "earth", "wind", "sun", "moon", "star", "tree", "stone", "mountain",
    ];

    println!("\nCoastal Language:");
    for concept in &concepts {
        println!("  {} → {}", concept, melodic.translate_word(concept));
    }

    println!("\nMountain Language:");
    for concept in &concepts {
        println!("  {} → {}", concept, harsh.translate_word(concept));
    }

    println!("\nScholar Language:");
    for concept in &concepts {
        println!("  {} → {}", concept, scholarly.translate_word(concept));
    }
}

pub fn translate_phrase(&self, phrase: &str) -> String

Translate a phrase to this language.

This splits the phrase into words, translates each word, and applies the language’s word order rules.

Example

use phyla_lang::{Language, CulturalProfile, Geography};

let culture = CulturalProfile::new(4.0, 3.0, 2.0, 3.0, 3.0, 4.0);
let language = Language::from_culture(culture, Geography::Coastal, 12345);

let phrase = language.translate_phrase("I bring the beer quickly");
assert!(!phrase.is_empty());

Examples found in repository

examples/basic_usage.rs (line 97)

fn demonstrate_language(language: &Language) {
    let phrases = vec![
        "I bring the beer quickly",
        "the sun rises in the east",
        "water flows down the mountain",
    ];

    for phrase in phrases {
        println!("   \"{}\" → \"{}\"", phrase, language.translate_phrase(phrase));
    }
}

examples/compare_with_js.rs (line 28)

fn main() {
    println!("=== Comparing Rust Implementation with JavaScript Demo ===\n");

    // Recreate the cultures from language_generator.html
    let melodic = create_melodic_coastal();
    let martial = create_mountain_warriors();
    let scholarly = create_river_scholars();
    let desert = create_desert_nomads();

    // Test phrase from the JavaScript demo
    let test_phrase = "I bring the beer quickly";

    println!("Translating: \"{}\"\n", test_phrase);

    println!("1. Melodic Coastal Folk (Agreeable, Emotional, Open)");
    println!("   Geography: Coastal plains");
    println!("   Word Order: {:?}", melodic.word_order());
    println!("   Translation: \"{}\"", melodic.translate_phrase(test_phrase));
    println!();

    println!("2. Mountain Warriors (Disagreeable, Conscientious, Brave)");
    println!("   Geography: Mountains");
    println!("   Word Order: {:?}", martial.word_order());
    println!("   Translation: \"{}\"", martial.translate_phrase(test_phrase));
    println!();

    println!("3. River Valley Scholars (Open, Conscientious, Intellectual)");
    println!("   Geography: River valleys");
    println!("   Word Order: {:?}", scholarly.word_order());
    println!("   Translation: \"{}\"", scholarly.translate_phrase(test_phrase));
    println!();

    println!("4. Desert Nomads (Independent, Hardy, Traditional)");
    println!("   Geography: Arid deserts");
    println!("   Word Order: {:?}", desert.word_order());
    println!("   Translation: \"{}\"", desert.translate_phrase(test_phrase));
    println!();

    // Demonstrate individual word translations
    println!("=== Individual Word Translations ===\n");

    let words = ["water", "sun", "mountain", "warrior", "peace"];

    for word in &words {
        println!("{:12} → Coastal: {:12} | Mountain: {:12} | Scholar: {:12} | Desert: {:12}",
            word,
            melodic.translate_word(word),
            martial.translate_word(word),
            scholarly.translate_word(word),
            desert.translate_word(word),
        );
    }

    println!("\n=== Phonological Characteristics ===\n");

    println!("Melodic Coastal Folk:");
    print_phonology(&melodic);

    println!("\nMountain Warriors:");
    print_phonology(&martial);

    println!("\nRiver Valley Scholars:");
    print_phonology(&scholarly);

    println!("\nDesert Nomads:");
    print_phonology(&desert);
}

pub fn word_order(&self) -> WordOrder

Get the word order of this language.

Examples found in repository

examples/compare_with_js.rs (line 27)

fn main() {
    println!("=== Comparing Rust Implementation with JavaScript Demo ===\n");

    // Recreate the cultures from language_generator.html
    let melodic = create_melodic_coastal();
    let martial = create_mountain_warriors();
    let scholarly = create_river_scholars();
    let desert = create_desert_nomads();

    // Test phrase from the JavaScript demo
    let test_phrase = "I bring the beer quickly";

    println!("Translating: \"{}\"\n", test_phrase);

    println!("1. Melodic Coastal Folk (Agreeable, Emotional, Open)");
    println!("   Geography: Coastal plains");
    println!("   Word Order: {:?}", melodic.word_order());
    println!("   Translation: \"{}\"", melodic.translate_phrase(test_phrase));
    println!();

    println!("2. Mountain Warriors (Disagreeable, Conscientious, Brave)");
    println!("   Geography: Mountains");
    println!("   Word Order: {:?}", martial.word_order());
    println!("   Translation: \"{}\"", martial.translate_phrase(test_phrase));
    println!();

    println!("3. River Valley Scholars (Open, Conscientious, Intellectual)");
    println!("   Geography: River valleys");
    println!("   Word Order: {:?}", scholarly.word_order());
    println!("   Translation: \"{}\"", scholarly.translate_phrase(test_phrase));
    println!();

    println!("4. Desert Nomads (Independent, Hardy, Traditional)");
    println!("   Geography: Arid deserts");
    println!("   Word Order: {:?}", desert.word_order());
    println!("   Translation: \"{}\"", desert.translate_phrase(test_phrase));
    println!();

    // Demonstrate individual word translations
    println!("=== Individual Word Translations ===\n");

    let words = ["water", "sun", "mountain", "warrior", "peace"];

    for word in &words {
        println!("{:12} → Coastal: {:12} | Mountain: {:12} | Scholar: {:12} | Desert: {:12}",
            word,
            melodic.translate_word(word),
            martial.translate_word(word),
            scholarly.translate_word(word),
            desert.translate_word(word),
        );
    }

    println!("\n=== Phonological Characteristics ===\n");

    println!("Melodic Coastal Folk:");
    print_phonology(&melodic);

    println!("\nMountain Warriors:");
    print_phonology(&martial);

    println!("\nRiver Valley Scholars:");
    print_phonology(&scholarly);

    println!("\nDesert Nomads:");
    print_phonology(&desert);
}

examples/basic_usage.rs (line 42)

fn main() {
    println!("=== Phyla-Lang: Procedural Language Generation ===\n");

    // Define different cultures
    let coastal_folk = CulturalProfile::new(
        4.0, // High agreeableness - cooperative, empathetic
        3.0, // Moderate openness
        2.0, // Lower conscientiousness - more flexible
        3.0, // Moderate extraversion
        3.0, // Moderate honesty-humility
        4.0, // High emotionality - sensitive, expressive
    );

    let mountain_warriors = CulturalProfile::new(
        1.0, // Low agreeableness - more competitive
        2.0, // Lower openness - traditional
        4.0, // High conscientiousness - disciplined
        3.0, // Moderate extraversion
        3.0, // Moderate honesty-humility
        2.0, // Lower emotionality - stoic
    );

    let river_scholars = CulturalProfile::new(
        3.0, // Moderate agreeableness
        4.0, // High openness - innovative, curious
        4.0, // High conscientiousness - organized
        3.0, // Moderate extraversion
        4.0, // High honesty-humility - modest, sincere
        3.0, // Moderate emotionality
    );

    // Create languages
    let melodic = Language::from_culture(coastal_folk, Geography::Coastal, 1001);
    let harsh = Language::from_culture(mountain_warriors, Geography::Mountains, 1002);
    let scholarly = Language::from_culture(river_scholars, Geography::RiverValley, 1003);

    println!("1. MELODIC COASTAL LANGUAGE (Agreeable, Emotional, Coastal)");
    println!("   Word order: {:?}", melodic.word_order());
    demonstrate_language(&melodic);

    println!("\n2. MOUNTAIN WARRIOR LANGUAGE (Disagreeable, Conscientious, Mountains)");
    println!("   Word order: {:?}", harsh.word_order());
    demonstrate_language(&harsh);

    println!("\n3. RIVER VALLEY SCHOLAR LANGUAGE (Open, Conscientious, River Valley)");
    println!("   Word order: {:?}", scholarly.word_order());
    demonstrate_language(&scholarly);

    // Demonstrate determinism
    println!("\n=== DETERMINISM DEMONSTRATION ===");
    println!("Creating two identical languages with the same parameters...\n");

    let lang1 = Language::from_culture(coastal_folk, Geography::Coastal, 5555);
    let lang2 = Language::from_culture(coastal_folk, Geography::Coastal, 5555);

    let word1 = lang1.translate_word("forever");
    let word2 = lang2.translate_word("forever");

    println!("Language 1 translates 'forever' as: {}", word1);
    println!("Language 2 translates 'forever' as: {}", word2);
    println!("Are they the same? {}", word1 == word2);

    // Demonstrate word variation
    println!("\n=== VOCABULARY SAMPLE ===");
    let concepts = vec![
        "water", "fire", "earth", "wind", "sun", "moon", "star", "tree", "stone", "mountain",
    ];

    println!("\nCoastal Language:");
    for concept in &concepts {
        println!("  {} → {}", concept, melodic.translate_word(concept));
    }

    println!("\nMountain Language:");
    for concept in &concepts {
        println!("  {} → {}", concept, harsh.translate_word(concept));
    }

    println!("\nScholar Language:");
    for concept in &concepts {
        println!("  {} → {}", concept, scholarly.translate_word(concept));
    }
}

pub fn clear_cache(&self)

Clear the lexicon cache.

pub fn cache_size(&self) -> usize

Get the number of cached words.