feat: new parser strategy

pkg/saccharine/scan.go

@@ -1,44 +1,13 @@
 package saccharine
 
 import (
-	"errors"
 	"fmt"
 	"unicode"
 
 	"git.maximhutz.com/max/lambda/pkg/iterator"
+	"git.maximhutz.com/max/lambda/pkg/token"
 )
 
-// isVariables determines whether a rune can be a valid variable.
-func isVariable(r rune) bool {
-	return unicode.IsLetter(r) || unicode.IsNumber(r)
-}
-
-func scanRune(i *iterator.Iterator[rune], expected func(rune) bool) (rune, error) {
-	i2 := i.Copy()
-
-	if r, err := i2.Next(); err != nil {
-		return r, err
-	} else if !expected(r) {
-		return r, fmt.Errorf("got unexpected rune %v'", r)
-	} else {
-		i.Sync(i2)
-		return r, nil
-	}
-}
-
-func scanCharacter(i *iterator.Iterator[rune], expected rune) (rune, error) {
-	i2 := i.Copy()
-
-	if r, err := i2.Next(); err != nil {
-		return r, err
-	} else if r != expected {
-		return r, fmt.Errorf("got unexpected rune %v'", r)
-	} else {
-		i.Sync(i2)
-		return r, nil
-	}
-}
-
 // Pulls the next token from an iterator over runes. If it cannot, it will
 // return nil. If an error occurs, it will return that.
 func scanToken(i *iterator.Iterator[rune]) (*Token, error) {
@@ -55,27 +24,27 @@ func scanToken(i *iterator.Iterator[rune]) (*Token, error) {
 
 	switch {
 	case letter == '(':
-		return NewToken(TokenOpenParen, index), nil
+		return token.New(TokenOpenParen, index), nil
 	case letter == ')':
-		return NewToken(TokenCloseParen, index), nil
+		return token.New(TokenCloseParen, index), nil
 	case letter == '.':
-		return NewToken(TokenDot, index), nil
+		return token.New(TokenDot, index), nil
 	case letter == '\\':
-		return NewToken(TokenSlash, index), nil
+		return token.New(TokenSlash, index), nil
 	case letter == '\n':
-		return NewToken(TokenSoftBreak, index), nil
+		return token.New(TokenSoftBreak, index), nil
 	case letter == '{':
-		return NewToken(TokenOpenBrace, index), nil
+		return token.New(TokenOpenBrace, index), nil
 	case letter == '}':
-		return NewToken(TokenCloseBrace, index), nil
+		return token.New(TokenCloseBrace, index), nil
 	case letter == ':':
-		if _, err := scanCharacter(i, '='); err != nil {
+		if _, err := token.ScanCharacter(i, '='); err != nil {
 			return nil, err
 		} else {
-			return NewToken(TokenAssign, index), nil
+			return token.New(TokenAssign, index), nil
 		}
 	case letter == ';':
-		return NewToken(TokenHardBreak, index), nil
+		return token.New(TokenHardBreak, index), nil
 	case letter == '#':
 		// Skip everything until the next newline or EOF.
 		for !i.Done() {
@@ -93,18 +62,8 @@ func scanToken(i *iterator.Iterator[rune]) (*Token, error) {
 		return nil, nil
 	case unicode.IsSpace(letter):
 		return nil, nil
-	case isVariable(letter):
-		atom := []rune{letter}
-
-		for {
-			if r, err := scanRune(i, isVariable); err != nil {
-				break
-			} else {
-				atom = append(atom, r)
-			}
-		}
-
-		return NewTokenAtom(string(atom), index), nil
+	case token.IsVariable(letter):
+		return token.ScanAtom(i, letter, TokenAtom, index), nil
 	}
 
 	return nil, fmt.Errorf("unknown character '%v'", string(letter))
@@ -112,18 +71,5 @@ func scanToken(i *iterator.Iterator[rune]) (*Token, error) {
 
 // scan a string into tokens.
 func scan(input string) ([]Token, error) {
-	i := iterator.Of([]rune(input))
-	tokens := []Token{}
-	errorList := []error{}
-
-	for !i.Done() {
-		token, err := scanToken(i)
-		if err != nil {
-			errorList = append(errorList, err)
-		} else if token != nil {
-			tokens = append(tokens, *token)
-		}
-	}
-
-	return tokens, errors.Join(errorList...)
+	return token.Scan(input, scanToken)
 }