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

feat: cleaner parsing functions

Browse Source
This commit is contained in:
Maxim Hutz
2025-12-27 20:46:10 -05:00
parent c37e96770f
commit 14fc4b30da
5 changed files with 121 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
pkg/iterator/iterator.go
View File

@@ -48,6 +48,12 @@ func (i Iterator[T]) MustGet() T {
return i.items[i.index] return i.items[i.index]
} }
func (i *Iterator[T]) Forward() {
if !i.Done() {
i.index++
}
}
// Create a new iterator, over a set of items. // Create a new iterator, over a set of items.
func (i *Iterator[T]) Next() (T, error) { func (i *Iterator[T]) Next() (T, error) {
item, err := i.Get() item, err := i.Get()
@@ -67,3 +73,14 @@ func (i *Iterator[T]) Back() {
func (i Iterator[T]) Done() bool { func (i Iterator[T]) Done() bool {
return i.index == len(i.items) return i.index == len(i.items)
} }
func Do[T any, U any](i *Iterator[T], fn func(i *Iterator[T]) (U, error)) (U, error) {
i2 := i.Copy()
out, err := fn(i2)
if err == nil {
i.Sync(i2)
}
return out, err
}

155
pkg/saccharine/parser.go
View File

@@ -11,101 +11,114 @@ import (
type TokenIterator = iterator.Iterator[token.Token] type TokenIterator = iterator.Iterator[token.Token]
func parseToken(i *TokenIterator, expected token.Type) (*token.Token, error) { func parseRawToken(i *TokenIterator, expected token.Type) (*token.Token, error) {
i2 := i.Copy() return iterator.Do(i, func(i *TokenIterator) (*token.Token, error) {
if tok, err := i.Next(); err != nil {
return nil, err
} else if tok.Type != expected {
return nil, fmt.Errorf("expected token %v, got %v'", token.Name(expected), tok.Value)
} else {
return &tok, nil
}
})
}
if tok, err := i2.Next(); err != nil { func passSoftBreaks(i *TokenIterator) {
return nil, err for {
} else if tok.Type != expected { if _, err := parseRawToken(i, token.SoftBreak); err != nil {
return nil, fmt.Errorf("expected token %v, got %v'", token.Name(expected), tok.Value) return
} else { }
i.Sync(i2)
return &tok, nil
} }
} }
func parseToken(i *TokenIterator, expected token.Type, ignoreSoftBreaks bool) (*token.Token, error) {
return iterator.Do(i, func(i *TokenIterator) (*token.Token, error) {
if ignoreSoftBreaks {
passSoftBreaks(i)
}
return parseRawToken(i, expected)
})
}
func parseExpression(i *TokenIterator) (ast.Expression, error) { func parseExpression(i *TokenIterator) (ast.Expression, error) {
var err error return iterator.Do(i, func(i *TokenIterator) (ast.Expression, error) {
var exp ast.Expression passSoftBreaks(i)
peek := i.MustGet() peek := i.MustGet()
switch peek.Type { switch peek.Type {
case token.OpenParen: case token.OpenParen:
exp, err = parseApplication(i) return parseApplication(i)
case token.Slash: case token.Slash:
exp, err = parseAbstraction(i) return parseAbstraction(i)
case token.Atom: case token.Atom:
exp, err = parseAtom(i) return parseAtom(i)
default: default:
return nil, fmt.Errorf("expected expression, got '%v' (col %d)", peek.Value, peek.Column) return nil, fmt.Errorf("expected expression, got '%v' (col %d)", peek.Value, peek.Column)
} }
})
return exp, err
} }
func parseParameters(i *TokenIterator) ([]string, error) { func parseParameters(i *TokenIterator) ([]string, error) {
i2 := i.Copy() return iterator.Do(i, func(i *TokenIterator) ([]string, error) {
variables := []string{} variables := []string{}
for { for {
if tok, err := parseToken(i2, token.Atom); err != nil { if tok, err := parseToken(i, token.Atom, true); err != nil {
break return variables, nil
} else { } else {
variables = append(variables, tok.Value) variables = append(variables, tok.Value)
}
} }
} })
i.Sync(i2)
return variables, nil
} }
func parseAbstraction(i *TokenIterator) (*ast.Abstraction, error) { func parseAbstraction(i *TokenIterator) (*ast.Abstraction, error) {
i2 := i.Copy() return iterator.Do(i, func(i *TokenIterator) (*ast.Abstraction, error) {
if _, err := parseToken(i, token.Slash, true); err != nil {
if _, err := parseToken(i2, token.Slash); err != nil { return nil, trace.Wrap(err, "no function slash (col %d)", i.MustGet().Column)
return nil, trace.WrapError(fmt.Errorf("no function slash (col %d)", i2.MustGet().Column), err) } else if parameters, err := parseParameters(i); err != nil {
} else if parameters, err := parseParameters(i2); err != nil { return nil, err
return nil, err } else if _, err = parseToken(i, token.Dot, true); err != nil {
} else if _, err = parseToken(i2, token.Dot); err != nil { return nil, trace.Wrap(err, "no function dot (col %d)", i.MustGet().Column)
return nil, trace.WrapError(fmt.Errorf("no function dot (col %d)", i2.MustGet().Column), err) } else if body, err := parseExpression(i); err != nil {
} else if body, err := parseExpression(i2); err != nil { return nil, err
return nil, err } else {
} else { return ast.NewAbstraction(parameters, body), nil
i.Sync(i2) }
return ast.NewAbstraction(parameters, body), nil })
}
} }
func parseApplication(i *TokenIterator) (*ast.Application, error) { func parseApplication(i *TokenIterator) (*ast.Application, error) {
i2 := i.Copy() return iterator.Do(i, func(i *TokenIterator) (*ast.Application, error) {
expressions := []ast.Expression{} expressions := []ast.Expression{}
if _, err := parseToken(i2, token.OpenParen); err != nil { if _, err := parseToken(i, token.OpenParen, true); err != nil {
return nil, trace.WrapError(fmt.Errorf("no openning brackets (col %d)", i2.MustGet().Column), err) return nil, trace.Wrap(err, "no openning brackets (col %d)", i.MustGet().Column)
}
for {
if exp, err := parseExpression(i2); err != nil {
if len(expressions) == 0 {
return nil, trace.WrapError(fmt.Errorf("application has no arguments"), err)
}
break
} else {
expressions = append(expressions, exp)
} }
}
if _, err := parseToken(i2, token.CloseParen); err != nil { for {
return nil, trace.WrapError(fmt.Errorf("no closing brackets (col %d)", i2.MustGet().Column), err) if exp, err := parseExpression(i); err != nil {
} if len(expressions) == 0 {
return nil, trace.Wrap(err, "application has no arguments")
}
break
} else {
expressions = append(expressions, exp)
}
}
i.Sync(i2) if _, err := parseToken(i, token.CloseParen, true); err != nil {
return ast.NewApplication(expressions[0], expressions[1:]), nil return nil, trace.Wrap(err, "no closing brackets (col %d)", i.MustGet().Column)
}
return ast.NewApplication(expressions[0], expressions[1:]), nil
})
} }
func parseAtom(i *TokenIterator) (*ast.Atom, error) { func parseAtom(i *TokenIterator) (*ast.Atom, error) {
if tok, err := parseToken(i, token.Atom); err != nil { if tok, err := parseToken(i, token.Atom, true); err != nil {
return nil, trace.WrapError(fmt.Errorf("no variable (col %d)", i.Index()), err) return nil, trace.Wrap(err, "no variable (col %d)", i.Index())
} else { } else {
return ast.NewAtom(tok.Value), nil return ast.NewAtom(tok.Value), nil
} }

20
pkg/saccharine/token/token.go
View File

@@ -1,5 +1,7 @@
package token package token
import "fmt"
// All tokens in the pseudo-lambda language. // All tokens in the pseudo-lambda language.
type Type int type Type int
@@ -8,12 +10,12 @@ const (
CloseParen // Denotes the ')' token. CloseParen // Denotes the ')' token.
OpenBrace // Denotes the '{' token. OpenBrace // Denotes the '{' token.
CloseBrace // Denotes the '}' token. CloseBrace // Denotes the '}' token.
End // Denotes the ';' token. HardBreak // Denotes the ';' token.
Assign // Denotes the ':=' token. Assign // Denotes the ':=' token.
Atom // Denotes an alpha-numeric variable. Atom // Denotes an alpha-numeric variable.
Slash // Denotes the '/' token. Slash // Denotes the '/' token.
Dot // Denotes the '.' token. Dot // Denotes the '.' token.
Newline // Denotes a new-line. SoftBreak // Denotes a new-line.
) )
// A representation of a token in source code. // A representation of a token in source code.
@@ -43,8 +45,8 @@ func NewDot(column int) *Token {
return &Token{Type: Dot, Column: column, Value: "."} return &Token{Type: Dot, Column: column, Value: "."}
} }
func NewEnd(column int) *Token { func NewHardBreak(column int) *Token {
return &Token{Type: End, Column: column, Value: ";"} return &Token{Type: HardBreak, Column: column, Value: ";"}
} }
func NewAssign(column int) *Token { func NewAssign(column int) *Token {
@@ -59,8 +61,8 @@ func NewAtom(name string, column int) *Token {
return &Token{Type: Atom, Column: column, Value: name} return &Token{Type: Atom, Column: column, Value: name}
} }
func NewNewline(column int) *Token { func NewSoftBreak(column int) *Token {
return &Token{Type: Newline, Column: column, Value: "\\n"} return &Token{Type: SoftBreak, Column: column, Value: "\\n"}
} }
func Name(typ Type) string { func Name(typ Type) string {
@@ -75,10 +77,12 @@ func Name(typ Type) string {
return "." return "."
case Atom: case Atom:
return "ATOM" return "ATOM"
case Newline: case SoftBreak:
return "\\n" return "\\n"
case HardBreak:
return ";"
default: default:
return "?" panic(fmt.Errorf("unknown token type %v", typ))
} }
} }

10
pkg/saccharine/tokenizer.go
View File

@@ -52,7 +52,7 @@ func getToken(i *iterator.Iterator[rune]) (*token.Token, error) {
letter, err := i.Next() letter, err := i.Next()
if err != nil { if err != nil {
return nil, trace.WrapError(fmt.Errorf("cannot produce next token"), err) return nil, trace.Wrap(err, "cannot produce next token")
} }
switch { switch {
@@ -65,11 +65,11 @@ func getToken(i *iterator.Iterator[rune]) (*token.Token, error) {
case letter == '\\': case letter == '\\':
return token.NewSlash(index), nil return token.NewSlash(index), nil
case letter == '\n': case letter == '\n':
return token.NewNewline(index), nil return token.NewSoftBreak(index), nil
case letter == '{': case letter == '{':
return token.NewNewline(index), nil return token.NewOpenBrace(index), nil
case letter == '}': case letter == '}':
return token.NewNewline(index), nil return token.NewCloseBrace(index), nil
case letter == ':': case letter == ':':
if _, err := parseCharacter(i, '='); err != nil { if _, err := parseCharacter(i, '='); err != nil {
return nil, err return nil, err
@@ -77,7 +77,7 @@ func getToken(i *iterator.Iterator[rune]) (*token.Token, error) {
return token.NewAssign(index), nil return token.NewAssign(index), nil
} }
case letter == ';': case letter == ';':
return token.NewEnd(index), nil return token.NewHardBreak(index), nil
case unicode.IsSpace(letter): case unicode.IsSpace(letter):
return nil, nil return nil, nil
case isVariable(letter): case isVariable(letter):

4
pkg/trace/trace.go
View File

@@ -2,6 +2,7 @@ package trace
import ( import (
"errors" "errors"
"fmt"
"strings" "strings"
) )
@@ -17,7 +18,8 @@ func Indent(s string, size int) string {
return indented return indented
} }
func WrapError(parent error, child error) error { func Wrap(child error, format string, a ...any) error {
parent := fmt.Errorf(format, a...)
childErrString := Indent(child.Error(), 4) childErrString := Indent(child.Error(), 4)
return errors.New(parent.Error() + "\n" + childErrString) return errors.New(parent.Error() + "\n" + childErrString)
} }