M.V. Hutz
aca197ef51
## Description `iterator.Try` previously copied the entire iterator and synced it back on success, causing an unnecessary heap allocation on every call. This PR simplifies `Try` to save and restore the index directly, and removes the now-unused `Copy` and `Sync` methods. - Rewrite `ScanRune` and `ParseRawToken` as peek-then-advance, eliminating the need for `Try` at leaf level. - Remove redundant `Try` wrappers from `parseExpression`, `parseAbstraction`, `parseApplication`, `parseLet`, and `parseToken`, which are already disambiguated by their callers. - Keep `Try` only where true backtracking is needed: `parseStatement`, which must choose between `parseLet` and `parseDeclare`. - Fix pre-existing panic in saccharine `parseExpression` when the iterator is exhausted (added `Done()` guard). ### Decisions - `Try` now operates on the original iterator instead of a copy, removing the confusing pattern where the callback's `i` was a different object than the caller's `i`. - Removed `parseSoftBreak` and `parseHardBreak` helper functions since `ParseRawToken` no longer needs `Try` wrapping. ## Benefits - Eliminates a heap allocation per `Try` call. - Reduces nesting and indirection in all parse functions. - Makes the code easier to follow by removing the shadow-`i` pattern. - `Try` is now only used at genuine choice points in the grammar. ## Checklist - [x] Code follows conventional commit format. - [x] Branch follows naming convention (`<type>/<description>`). Always use underscores. - [x] Tests pass (if applicable). - [x] Documentation updated (if applicable). Reviewed-on: #47 Co-authored-by: M.V. Hutz <git@maximhutz.me> Co-committed-by: M.V. Hutz <git@maximhutz.me>
43 lines
1.2 KiB
Go
43 lines
1.2 KiB
Go
package token
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"git.maximhutz.com/max/lambda/pkg/iterator"
|
|
)
|
|
|
|
// ParseRawToken consumes the next token from the iterator if its type matches
|
|
// the expected type.
|
|
// Returns an error if the iterator is exhausted or the token type does not
|
|
// match.
|
|
func ParseRawToken[T Type](i *iterator.Iterator[Token[T]], expected T) (*Token[T], error) {
|
|
tok, err := i.Get()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if tok.Type != expected {
|
|
return nil, fmt.Errorf("expected token %v, got %v'", expected.Name(), tok.Value)
|
|
}
|
|
i.Forward()
|
|
return &tok, nil
|
|
}
|
|
|
|
// ParseList repeatedly applies a parse function, collecting results into a
|
|
// slice.
|
|
// Stops when the parse function returns an error.
|
|
// Returns an error if fewer than minimum results are collected.
|
|
func ParseList[T Type, U any](i *iterator.Iterator[Token[T]], fn func(*iterator.Iterator[Token[T]]) (U, error), minimum int) ([]U, error) {
|
|
results := []U{}
|
|
|
|
for {
|
|
if u, err := fn(i); err != nil {
|
|
if len(results) < minimum {
|
|
return nil, fmt.Errorf("expected at least '%v' items, got only '%v': %w", minimum, len(results), err)
|
|
}
|
|
return results, nil
|
|
} else {
|
|
results = append(results, u)
|
|
}
|
|
}
|
|
}
|