oak-wolfram 0.0.2

Wolfram Language parser with support for Mathematica syntax and symbolic computation.
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

# Oak Wolfram Parser


[![Crates.io](https://img.shields.io/crates/v/oak-wolfram.svg)](https://crates.io/crates/oak-wolfram)
[![Documentation](https://docs.rs/oak-wolfram/badge.svg)](https://docs.rs/oak-wolfram)

High-performance incremental Wolfram Language parser for the oak ecosystem with flexible configuration, optimized for mathematical computation and symbolic analysis.

## 🎯 Overview


Oak Wolfram is a robust parser for the Wolfram Language, designed to handle complete Wolfram syntax including mathematical expressions, symbolic computations, and functional programming constructs. Built on the solid foundation of oak-core, it provides both high-level convenience and detailed AST generation for mathematical analysis and code generation.

## ✨ Features


- **Complete Wolfram Syntax**: Supports all Wolfram Language features including mathematical expressions
- **Full AST Generation**: Generates comprehensive Abstract Syntax Trees
- **Lexer Support**: Built-in tokenization with proper span information
- **Error Recovery**: Graceful handling of syntax errors with detailed diagnostics

## 🚀 Quick Start


Basic example:

```rust
use oak_core::{Parser, SourceText, parser::session::ParseSession};
use oak_wolfram::{WolframParser, WolframLanguage};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut session = ParseSession::<WolframLanguage>::default();
    let parser = WolframParser::new();
    let source = SourceText::new(r#"
        f[x_] := x^2 + 2*x + 1
        Plot[f[x], {x, -10, 10}]
    "#);
    
    let result = parser.parse(&source, &[], &mut session);
    println!("Parsed Wolfram successfully.");
    Ok(())
}
```

## 📋 Parsing Examples


### Function Definition Parsing

```rust
use oak_core::{Parser, SourceText, parser::session::ParseSession};
use oak_wolfram::{WolframParser, WolframLanguage};

let mut session = ParseSession::<WolframLanguage>::default();
let parser = WolframParser::new();
let source = SourceText::new(r#"
    factorial[n_] := If[n <= 1, 1, n * factorial[n - 1]]
"#);

let result = parser.parse(&source, &[], &mut session);
println!("Function parsed successfully.");
```

### Expression Parsing

```rust
use oak_core::{Parser, SourceText, parser::session::ParseSession};
use oak_wolfram::{WolframParser, WolframLanguage};

let mut session = ParseSession::<WolframLanguage>::default();
let parser = WolframParser::new();
let source = SourceText::new(r#"
    Integrate[Sin[x], {x, 0, Pi}]
"#);

let result = parser.parse(&source, &[], &mut session);
println!("Expression parsed successfully.");
```

## 🔧 Advanced Features


### Token-Level Parsing

```rust
use oak_core::{Parser, SourceText, parser::session::ParseSession};
use oak_wolfram::{WolframParser, WolframLanguage};

let mut session = ParseSession::<WolframLanguage>::default();
let parser = WolframParser::new();
let source = SourceText::new("f[x_] := x^2");
let result = parser.parse(&source, &[], &mut session);
println!("Token parsing completed.");
```

### Error Handling

```rust
use oak_core::{Parser, SourceText, parser::session::ParseSession};
use oak_wolfram::{WolframParser, WolframLanguage};

let mut session = ParseSession::<WolframLanguage>::default();
let parser = WolframParser::new();
let source = SourceText::new(r#"
    f[x_ := x^2 + 1
    (* Missing closing bracket *)
"#);

let result = parser.parse(&source, &[], &mut session);
if let Some(errors) = result.result.err() {
    println!("Parse errors found: {:?}", errors);
} else {
    println!("Parsed successfully.");
}
```

## 🏗️ AST Structure


The parser generates a comprehensive AST with the following main structures:

- **Expression**: Mathematical and symbolic expressions
- **FunctionDefinition**: Function definitions with patterns
- **Rule**: Rewrite rules and transformations
- **List**: Ordered collections of expressions
- **Symbol**: Atomic symbols and identifiers

## 📊 Performance


- **Streaming**: Parse large Wolfram expressions without loading entirely into memory
- **Incremental**: Re-parse only changed sections
- **Memory Efficient**: Smart AST node allocation
- **Fast Recovery**: Quick error recovery for better IDE integration

## 🔗 Integration


Oak Wolfram integrates seamlessly with:

- **Mathematical Computation**: Symbolic mathematics and calculus
- **Code Generation**: Generating code from Wolfram expressions
- **IDE Support**: Language server protocol compatibility
- **Educational Tools**: Mathematical expression parsing for learning platforms
- **Scientific Computing**: Parsing and analyzing mathematical models

## 📚 Examples


Check out the [examples](examples/) directory for comprehensive examples:

- Complete Wolfram expression parsing
- Function and rule analysis
- Mathematical expression transformation
- Integration with development workflows

## 🤝 Contributing


Contributions are welcome! 

Please feel free to submit pull requests at the [project repository](https://github.com/ygg-lang/oaks/tree/dev/examples/oak-wolfram) or open [issues](https://github.com/ygg-lang/oaks/issues).