lambda/pkg/repr/saccharine/parse.go

package saccharine

import (
	"errors"
	"fmt"

	"git.maximhutz.com/max/lambda/pkg/iterator"
	"git.maximhutz.com/max/lambda/pkg/trace"
)

type TokenIterator = iterator.Iterator[Token]

func parseRawToken(i *TokenIterator, expected Type) (*Token, error) {
	return iterator.Do(i, func(i *TokenIterator) (*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'", Name(expected), tok.Value)
		} else {
			return &tok, nil
		}
	})
}

func passSoftBreaks(i *TokenIterator) {
	for {
		if _, err := parseRawToken(i, TokenSoftBreak); err != nil {
			return
		}
	}
}

func parseToken(i *TokenIterator, expected Type, ignoreSoftBreaks bool) (*Token, error) {
	return iterator.Do(i, func(i *TokenIterator) (*Token, error) {
		if ignoreSoftBreaks {
			passSoftBreaks(i)
		}

		return parseRawToken(i, expected)
	})
}

func parseString(i *TokenIterator) (string, error) {
	if tok, err := parseToken(i, TokenAtom, true); err != nil {
		return "", trace.Wrap(err, "no variable (col %d)", i.Index())
	} else {
		return tok.Value, nil
	}
}

func parseBreak(i *TokenIterator) (*Token, error) {
	if tok, softErr := parseRawToken(i, TokenSoftBreak); softErr == nil {
		return tok, nil
	} else if tok, hardErr := parseRawToken(i, TokenHardBreak); hardErr == nil {
		return tok, nil
	} else {
		return nil, errors.Join(softErr, hardErr)
	}
}

func parseList[U any](i *TokenIterator, fn func(*TokenIterator) (U, error), minimum int) ([]U, error) {
	results := []U{}

	for {
		if u, err := fn(i); err != nil {
			if len(results) < minimum {
				return nil, trace.Wrap(err, "expected at least '%v' items, got only '%v'", minimum, len(results))
			}
			return results, nil
		} else {
			results = append(results, u)
		}
	}
}

func parseAbstraction(i *TokenIterator) (*Abstraction, error) {
	return iterator.Do(i, func(i *TokenIterator) (*Abstraction, error) {
		if _, err := parseToken(i, TokenSlash, true); err != nil {
			return nil, trace.Wrap(err, "no function slash (col %d)", i.MustGet().Column)
		} else if parameters, err := parseList(i, parseString, 0); err != nil {
			return nil, err
		} else if _, err = parseToken(i, TokenDot, true); err != nil {
			return nil, trace.Wrap(err, "no function dot (col %d)", i.MustGet().Column)
		} else if body, err := parseExpression(i); err != nil {
			return nil, err
		} else {
			return NewAbstraction(parameters, body), nil
		}
	})
}

func parseApplication(i *TokenIterator) (*Application, error) {
	return iterator.Do(i, func(i *TokenIterator) (*Application, error) {
		if _, err := parseToken(i, TokenOpenParen, true); err != nil {
			return nil, trace.Wrap(err, "no openning brackets (col %d)", i.MustGet().Column)
		} else if expressions, err := parseList(i, parseExpression, 1); err != nil {
			return nil, err
		} else if _, err := parseToken(i, TokenCloseParen, true); err != nil {
			return nil, trace.Wrap(err, "no closing brackets (col %d)", i.MustGet().Column)
		} else {
			return NewApplication(expressions[0], expressions[1:]), nil
		}
	})
}

func parseAtom(i *TokenIterator) (*Variable, error) {
	if tok, err := parseToken(i, TokenAtom, true); err != nil {
		return nil, trace.Wrap(err, "no variable (col %d)", i.Index())
	} else {
		return NewVariable(tok.Value), nil
	}
}

func parseStatements(i *TokenIterator) ([]Statement, error) {
	statements := []Statement{}

	//nolint:errcheck
	parseList(i, parseBreak, 0)

	for {
		if statement, err := parseStatement(i); err != nil {
			break
		} else if _, err := parseList(i, parseBreak, 1); err != nil && !i.Done() {
			break
		} else {
			statements = append(statements, statement)
		}
	}

	return statements, nil
}

func parseClause(i *TokenIterator, braces bool) (*Clause, error) {
	if braces {
		if _, err := parseToken(i, TokenOpenBrace, true); err != nil {
			return nil, err
		}
	}

	var stmts []Statement
	var last *DeclareStatement
	var err error
	var ok bool

	if stmts, err = parseStatements(i); err != nil {
		return nil, err
	} else if len(stmts) == 0 {
		return nil, fmt.Errorf("no statements in clause")
	} else if last, ok = stmts[len(stmts)-1].(*DeclareStatement); !ok {
		return nil, fmt.Errorf("this clause contains no final return value (col %d)", i.MustGet().Column)
	}

	if braces {
		if _, err := parseToken(i, TokenCloseBrace, true); err != nil {
			return nil, err
		}
	}

	return NewClause(stmts[:len(stmts)-1], last.Value), nil
}

func parseExpression(i *TokenIterator) (Expression, error) {
	return iterator.Do(i, func(i *TokenIterator) (Expression, error) {
		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)
		}
	})
}

func parseLet(i *TokenIterator) (*LetStatement, error) {
	return iterator.Do(i, func(i *TokenIterator) (*LetStatement, error) {
		if parameters, err := 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 NewLet(parameters[0], parameters[1:], body), nil
		}
	})
}

func parseDeclare(i *TokenIterator) (*DeclareStatement, error) {
	if value, err := parseExpression(i); err != nil {
		return nil, err
	} else {
		return NewDeclare(value), nil
	}
}

func parseStatement(i *TokenIterator) (Statement, error) {
	if let, letErr := parseLet(i); letErr == nil {
		return let, nil
	} else if declare, declErr := parseDeclare(i); declErr == nil {
		return declare, nil
	} else {
		return nil, errors.Join(letErr, declErr)
	}
}

// Given a list of tokens, attempt to parse it into an syntax tree.
func parse(tokens []Token) (Expression, error) {
	i := iterator.Of(tokens)

	exp, err := parseClause(i, false)
	if err != nil {
		return nil, err
	}

	if !i.Done() {
		return nil, fmt.Errorf("expected EOF, found more code (col %d)", i.MustGet().Column)
	}

	return exp, nil
}

// Convert a piece of valid saccharine code into an expression.
func Parse(code string) (Expression, error) {
	tokens, err := Scan(code)
	if err != nil {
		return nil, err
	}

	return parse(tokens)
}