lynxql 0.1.1

A parser for the Lynx declarative modeling language - a statically typed language for expressing combinatorial optimization problems
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

use lynxql::parse_program;
use std::fs;

fn main() {
    let lynx_code = match fs::read_to_string("example.lynx") {
        Ok(content) => content,
        Err(_) => {
            // Fallback to a simple example if file doesn't exist
            r#"
// Simple type alias
type Size: int

// Primitive type with properties
type Hammer: bool {
    material: string,
    size: Size,
    cost: float
}

// Instance declaration using new syntax
Hammer hammer1 {
    material: "steel",
    size: 10,
    cost: 25.0
}

// Assignment with field access
test_cost = hammer1.cost

// Solve call
result = solve(hammer1, { hammer1: 1.0 })
            "#.to_string()
        }
    };

    println!("Parsing Lynx code...\n");
    
    match parse_program(&lynx_code) {
        Ok(program) => {
            println!("✅ Parse successful!");
            println!("📊 Found {} statements:", program.statements.len());
            
            for (i, stmt) in program.statements.iter().enumerate() {
                println!("  {}. {}", i + 1, match stmt {
                    lynxql::Statement::TypeDecl(t) => format!("Type declaration: {}", t.name),
                    lynxql::Statement::EnumDecl(e) => format!("Enum declaration: {}", e.name),
                    lynxql::Statement::Assignment(a) => {
                        if a.type_name.is_empty() {
                            format!("Assignment: {}", a.name)
                        } else {
                            format!("Instance declaration: {} : {}", a.name, a.type_name)
                        }
                    },
                    lynxql::Statement::SolveCall(_) => "Solve call".to_string(),
                });
            }
            
            println!("\n🔍 AST structure:");
            println!("{:#?}", program);
        }
        Err(e) => {
            eprintln!("❌ Parse error: {}", e);
        }
    }
}