mvhutz/lambda
1
0
Fork 0
Code Issues 3 Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: simplify iterator.Try and remove unnecessary backtracking

Browse Source 
Simplify Try to save/restore the index directly instead of
copying and syncing the entire iterator. Remove the now-unused
Copy and Sync methods.

Rewrite ScanRune and ParseRawToken as peek-then-advance so they
no longer need Try at all. Remove redundant Try wrappers from
parse functions that are already disambiguated by their callers.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Maxim Hutz
2026-02-11 20:04:07 -05:00
parent da3da70855
commit b1fef85d60
5 changed files with 114 additions and 136 deletions
Download Patch File Download Diff File Expand all files Collapse all files

110
pkg/saccharine/parse.go
View File

@@ -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)