sipha-parse 0.3.0

# sipha-parse

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Repository](https://img.shields.io/badge/github-sipha-blue)](https://github.com/NyalephTheCat/sipha)
[![Crates.io](https://img.shields.io/crates/v/sipha-parse)](https://crates.io/crates/sipha-parse)
[![docs.rs](https://docs.rs/sipha-parse/badge.svg)](https://docs.rs/sipha-parse)

Core parsing engine for sipha - grammar evaluation, parser state, and error recovery.

## Overview

`sipha-parse` provides the core parsing engine for sipha:

- **Parser**: Main parser struct with grammar rule evaluation
- **ParserState**: Manages parser state, token stream, and CST arena
- **GrammarRule**: Enum for defining grammar rules
- **GrammarRuleBuilder**: Fluent builder for constructing grammar rules
- **Helper functions**: Convenient functions for building grammars

## Quick Start

Add `sipha-parse` to your `Cargo.toml`:

```toml
[dependencies]
sipha-parse = "0.1.1"
```

## Example

```rust
use sipha_core::{span::Span, token::Token, traits::TokenKind};
use sipha_parse::{Parser, ParserState, helpers};
use sipha_tree::{NodeArena, RawNodeId};

#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
enum Token { Ident, Plus }
impl TokenKind for Token { fn is_trivia(&self) -> bool { false } }

#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
enum Rule { Expr }

let mut parser = Parser::create();
parser.register_rule(
    Rule::Expr,
    helpers::seq(vec![
        helpers::token(Token::Ident),
        helpers::token(Token::Plus),
        helpers::token(Token::Ident),
    ]),
);

let tokens = vec![
    Token::create(Token::Ident, Span::new(0, 1), "a", Vec::new(), Vec::new()),
    Token::create(Token::Plus, Span::new(1, 2), "+", Vec::new(), Vec::new()),
    Token::create(Token::Ident, Span::new(2, 3), "b", Vec::new(), Vec::new()),
];

let mut arena: NodeArena<Token, Rule, RawNodeId> = NodeArena::new();
let mut state = ParserState::new(&tokens, &mut arena, false, ());

match parser.parse_rule(Rule::Expr, &mut state) {
    Ok(_) => println!("Parsed successfully!"),
    Err(e) => eprintln!("Parse error: {:?}", e),
}
```

## License

This project is licensed under the MIT License - see the [LICENSE](../LICENSE) file for details.