Hello!

I'm excited to collaborate with you on a new project. We'll engage in a dialogue to make steady progress, so let's keep our conversations concise and organized. I prefer brief inputs as I have limited time to digest large chunks of information.

Our goal is to comprehensively develop the entire project, which includes writing all the code, documentation, and formulating ideas. Let's start with writing code directly, without unnecessary questions. Here are my initial thoughts for the project:

Project Overview:

    Name: Kolibro
    Goal: Develop a robust programming language
    Key Features:
        No garbage collection
        Memory safety
        Static typing
        Inspired by Haskell, Rust, and Python
    Requirement: Create an in-house parser generator called "thepg" before progressing further

Current Code:
```rust
use std::collections::HashMap;
use std::collections::HashSet;
use std::collections::hash_map::Entry;

#[derive(Debug, Clone)]
enum RuleString {
    Sequence(Box<RuleString>, Box<RuleString>),
    Alternative(Box<RuleString>, Box<RuleString>),
    ZeroOrMore(Box<RuleString>),
    Optional(Box<RuleString>),
    Terminal(char),
    NonTerminal(String),
}

#[derive(Debug, Clone)]
struct Rule {
    lhs: String,
    rhs: RuleString,
}

#[derive(Debug)]
struct Grammar {
    rules: Vec<Rule>,
}

impl<'a> From<&'a Grammar> for ResolvedGrammar<'a> {
    fn from(grammar: &'a Grammar) -> Self {
        let mut rule_map = HashMap::new();

        for rule in &grammar.rules {
            match rule_map.entry(&rule.lhs) {
                Entry::Vacant(entry) => {
                    entry.insert(rule.rhs);
                }
                Entry::Occupied(_) => {
                    panic!("Duplicate rule found for non-terminal: {}", rule.lhs);
                }
            }
        }

        rule_map.values().map(|rule_string| )
{ rule_string }
    }
}

fn main() {
    let digit_rule = Rule {
        lhs: "digit".to_owned(),
        rhs: RuleString::Alternative(
            Box::new(RuleString::Terminal('0')),
            Box::new(RuleString::Alternative(
                Box::new(RuleString::Terminal('1')),
                Box::new(RuleString::Alternative(
                    Box::new(RuleString::Terminal('2')),
                    Box::new(RuleString::Alternative(
                        Box::new(RuleString::Terminal('3')),
                        Box::new(RuleString::Alternative(
                            Box::new(RuleString::Terminal('4')),
                            Box::new(RuleString::Alternative(
                                Box::new(RuleString::Terminal('5')),
                                Box::new(RuleString::Alternative(
                                    Box::new(RuleString::Terminal('6')),
                                    Box::new(RuleString::Alternative(
                                        Box::new(RuleString::Terminal('7')),
                                        Box::new(RuleString::Alternative(
                                            Box::new(RuleString::Terminal('8')),
                                            Box::new(RuleString::Terminal('9')),
                                        )),
                                    )),
                                )),
                            )),
                        )),
                    )),
                )),
            )),
        ),
    };

    // "expr = digit '+' digit"
    let expr_rule = Rule {
        lhs: "expr".to_string(),
        rhs: RuleString::Sequence(
            Box::new(RuleString::NonTerminal("digit".to_string())),
            Box::new(RuleString::Sequence(
                Box::new(RuleString::Terminal('+')),
                Box::new(RuleString::NonTerminal("digit".to_string())),
            )),
        ),
    };

    let grammar = Grammar { rules: vec![digit_rule, expr_rule] };

    println!("thepg - parser generator");
}

#[derive(Debug)]
enum ResolvedRuleString<'a> {
    Sequence(Box<ResolvedRuleString<'a>>, Box<ResolvedRuleString<'a>>),
    Alternative(Box<ResolvedRuleString<'a>>, Box<ResolvedRuleString<'a>>),
    ZeroOrMore(Box<ResolvedRuleString<'a>>),
    Optional(Box<ResolvedRuleString<'a>>),
    Terminal(char),
    NonTerminal(&'a ResolvedRuleString<'a>),
}

#[derive(Debug)]
struct ResolvedGrammar<'a> {
    rules: Vec<ResolvedRule<'a>>,
}
```