refactor: simplify iterator.Try and remove unnecessary backtracking (#47)
## 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>
This commit was merged in pull request #47.
This commit is contained in:
@@ -19,13 +19,11 @@ func passSoftBreaks(i *tokenIterator) {
|
||||
}
|
||||
|
||||
func parseToken(i *tokenIterator, expected TokenType, ignoreSoftBreaks bool) (*Token, error) {
|
||||
return iterator.Try(i, func(i *tokenIterator) (*Token, error) {
|
||||
if ignoreSoftBreaks {
|
||||
passSoftBreaks(i)
|
||||
}
|
||||
if ignoreSoftBreaks {
|
||||
passSoftBreaks(i)
|
||||
}
|
||||
|
||||
return token.ParseRawToken(i, expected)
|
||||
})
|
||||
return token.ParseRawToken(i, expected)
|
||||
}
|
||||
|
||||
func parseString(i *tokenIterator) (string, error) {
|
||||
@@ -47,33 +45,29 @@ func parseBreak(i *tokenIterator) (*Token, error) {
|
||||
}
|
||||
|
||||
func parseAbstraction(i *tokenIterator) (*Abstraction, error) {
|
||||
return iterator.Try(i, func(i *tokenIterator) (*Abstraction, error) {
|
||||
if _, err := parseToken(i, TokenSlash, true); err != nil {
|
||||
return nil, fmt.Errorf("no function slash (col %d): %w", i.MustGet().Column, err)
|
||||
} else if parameters, err := token.ParseList(i, parseString, 0); err != nil {
|
||||
return nil, err
|
||||
} else if _, err = parseToken(i, TokenDot, true); err != nil {
|
||||
return nil, fmt.Errorf("no function dot (col %d): %w", i.MustGet().Column, err)
|
||||
} else if body, err := parseExpression(i); err != nil {
|
||||
return nil, err
|
||||
} else {
|
||||
return &Abstraction{Parameters: parameters, Body: body}, nil
|
||||
}
|
||||
})
|
||||
if _, err := parseToken(i, TokenSlash, true); err != nil {
|
||||
return nil, fmt.Errorf("no function slash (col %d): %w", i.MustGet().Column, err)
|
||||
} else if parameters, err := token.ParseList(i, parseString, 0); err != nil {
|
||||
return nil, err
|
||||
} else if _, err = parseToken(i, TokenDot, true); err != nil {
|
||||
return nil, fmt.Errorf("no function dot (col %d): %w", i.MustGet().Column, err)
|
||||
} else if body, err := parseExpression(i); err != nil {
|
||||
return nil, err
|
||||
} else {
|
||||
return &Abstraction{Parameters: parameters, Body: body}, nil
|
||||
}
|
||||
}
|
||||
|
||||
func parseApplication(i *tokenIterator) (*Application, error) {
|
||||
return iterator.Try(i, func(i *tokenIterator) (*Application, error) {
|
||||
if _, err := parseToken(i, TokenOpenParen, true); err != nil {
|
||||
return nil, fmt.Errorf("no openning brackets (col %d): %w", i.MustGet().Column, err)
|
||||
} else if expressions, err := token.ParseList(i, parseExpression, 1); err != nil {
|
||||
return nil, err
|
||||
} else if _, err := parseToken(i, TokenCloseParen, true); err != nil {
|
||||
return nil, fmt.Errorf("no closing brackets (col %d): %w", i.MustGet().Column, err)
|
||||
} else {
|
||||
return &Application{Abstraction: expressions[0], Arguments: expressions[1:]}, nil
|
||||
}
|
||||
})
|
||||
if _, err := parseToken(i, TokenOpenParen, true); err != nil {
|
||||
return nil, fmt.Errorf("no openning brackets (col %d): %w", i.MustGet().Column, err)
|
||||
} else if expressions, err := token.ParseList(i, parseExpression, 1); err != nil {
|
||||
return nil, err
|
||||
} else if _, err := parseToken(i, TokenCloseParen, true); err != nil {
|
||||
return nil, fmt.Errorf("no closing brackets (col %d): %w", i.MustGet().Column, err)
|
||||
} else {
|
||||
return &Application{Abstraction: expressions[0], Arguments: expressions[1:]}, nil
|
||||
}
|
||||
}
|
||||
|
||||
func parseAtom(i *tokenIterator) (*Atom, error) {
|
||||
@@ -133,36 +127,36 @@ func parseClause(i *tokenIterator, braces bool) (*Clause, error) {
|
||||
}
|
||||
|
||||
func parseExpression(i *tokenIterator) (Expression, error) {
|
||||
return iterator.Try(i, func(i *tokenIterator) (Expression, error) {
|
||||
passSoftBreaks(i)
|
||||
passSoftBreaks(i)
|
||||
|
||||
switch peek := i.MustGet(); peek.Type {
|
||||
case TokenOpenParen:
|
||||
return parseApplication(i)
|
||||
case TokenSlash:
|
||||
return parseAbstraction(i)
|
||||
case TokenAtom:
|
||||
return parseAtom(i)
|
||||
case TokenOpenBrace:
|
||||
return parseClause(i, true)
|
||||
default:
|
||||
return nil, fmt.Errorf("expected expression, got '%v' (col %d)", peek.Value, peek.Column)
|
||||
}
|
||||
})
|
||||
if i.Done() {
|
||||
return nil, fmt.Errorf("unexpected end of input")
|
||||
}
|
||||
|
||||
switch peek := i.MustGet(); peek.Type {
|
||||
case TokenOpenParen:
|
||||
return parseApplication(i)
|
||||
case TokenSlash:
|
||||
return parseAbstraction(i)
|
||||
case TokenAtom:
|
||||
return parseAtom(i)
|
||||
case TokenOpenBrace:
|
||||
return parseClause(i, true)
|
||||
default:
|
||||
return nil, fmt.Errorf("expected expression, got '%v' (col %d)", peek.Value, peek.Column)
|
||||
}
|
||||
}
|
||||
|
||||
func parseLet(i *tokenIterator) (*LetStatement, error) {
|
||||
return iterator.Try(i, func(i *tokenIterator) (*LetStatement, error) {
|
||||
if parameters, err := token.ParseList(i, parseString, 1); err != nil {
|
||||
return nil, err
|
||||
} else if _, err := parseToken(i, TokenAssign, true); err != nil {
|
||||
return nil, err
|
||||
} else if body, err := parseExpression(i); err != nil {
|
||||
return nil, err
|
||||
} else {
|
||||
return &LetStatement{Name: parameters[0], Parameters: parameters[1:], Body: body}, nil
|
||||
}
|
||||
})
|
||||
if parameters, err := token.ParseList(i, parseString, 1); err != nil {
|
||||
return nil, err
|
||||
} else if _, err := parseToken(i, TokenAssign, true); err != nil {
|
||||
return nil, err
|
||||
} else if body, err := parseExpression(i); err != nil {
|
||||
return nil, err
|
||||
} else {
|
||||
return &LetStatement{Name: parameters[0], Parameters: parameters[1:], Body: body}, nil
|
||||
}
|
||||
}
|
||||
|
||||
func parseDeclare(i *tokenIterator) (*DeclareStatement, error) {
|
||||
@@ -174,9 +168,9 @@ func parseDeclare(i *tokenIterator) (*DeclareStatement, error) {
|
||||
}
|
||||
|
||||
func parseStatement(i *tokenIterator) (Statement, error) {
|
||||
if let, letErr := parseLet(i); letErr == nil {
|
||||
if let, letErr := iterator.Try(i, parseLet); letErr == nil {
|
||||
return let, nil
|
||||
} else if declare, declErr := parseDeclare(i); declErr == nil {
|
||||
} else if declare, declErr := iterator.Try(i, parseDeclare); declErr == nil {
|
||||
return declare, nil
|
||||
} else {
|
||||
return nil, errors.Join(letErr, declErr)
|
||||
|
||||
Reference in New Issue
Block a user