add loop expression

ast/ast.go

@@ -129,6 +129,31 @@ func (ie *IfExpression) String() string {
 	return out.String()
 }
 
+type LoopExpression struct {
+	Token token.Token
+	Index *Symbol
+	From  *IntegerLiteral
+	To    *IntegerLiteral
+	Body  Expression
+}
+
+func (le *LoopExpression) TokenLiteral() string { return le.Token.Literal }
+func (le *LoopExpression) String() string {
+	var out bytes.Buffer
+
+	out.WriteString("{\"loop\": {\"for\": ")
+	out.WriteString(le.Index.String())
+	out.WriteString(", \"from\": ")
+	out.WriteString(le.From.String())
+	out.WriteString(", \"to\": ")
+	out.WriteString(le.To.String())
+	out.WriteString(", \"body\": ")
+	out.WriteString(le.Body.String())
+	out.WriteString("}}")
+
+	return out.String()
+}
+
 type SetExpression struct {
 	Token token.Token
 	Name  *Symbol

evaluator/evaluator.go

@@ -39,6 +39,8 @@ func Eval(exp ast.Expression, env *object.Environment) object.Object {
 			return value
 		}
 		return env.Set(expt.Name.Value, value)
+	case *ast.LoopExpression:
+		return evalLoopExpression(expt, env)
 	default:
 		return newError("unknown expression type: %T", exp)
 	}
@@ -162,3 +164,37 @@ func isTruthy(obj object.Object) bool {
 		return true
 	}
 }
+
+func evalLoopExpression(le *ast.LoopExpression, env *object.Environment) object.Object {
+	from := Eval(le.From, env)
+	if isError(from) {
+		return from
+	}
+	fromValue, ok := from.(*object.Integer)
+	if !ok {
+		return newError("from value must be INTEGER, got %s", from.Type())
+	}
+
+	to := Eval(le.To, env)
+	if isError(to) {
+		return to
+	}
+	toValue, ok := to.(*object.Integer)
+	if !ok {
+		return newError("to value must be INTEGER, got %s", to.Type())
+	}
+
+	var result object.Object
+
+	for i := fromValue.Value; i < toValue.Value; i++ {
+		env.Set(le.Index.Value, &object.Integer{Value: i})
+		evaluated := Eval(le.Body, env)
+		if isError(evaluated) {
+			return evaluated
+		}
+
+		result = evaluated
+	}
+
+	return result
+}

evaluator/evaluator_test.go

@@ -369,6 +369,40 @@ func TestIfElseExpression(t *testing.T) {
 	}
 }
 
+func TestLoopExpression(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected int64
+	}{
+		{
+			name: "loop expression",
+			input: `
+				{
+					"loop": {
+						"for": "$i",
+						"from": 1,
+						"to": 3,
+						"do": {
+							"command": {
+								"symbol": "+",
+								"args": [1, "$i"]
+							}
+						}
+					}
+				}`,
+			expected: 3,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			evaluated := testEval(t, tt.input)
+			testIntegerObject(t, evaluated, tt.expected)
+		})
+	}
+}
+
 func TestSetExpression(t *testing.T) {
 	tests := []struct {
 		name     string

lexer/lexer_test.go

@@ -562,6 +562,85 @@ func TestSingleProgram(t *testing.T) {
 				{Type: token.EOF, Literal: ""},
 			},
 		},
+		{
+			name: "loop expression",
+			input: `
+				{
+					"loop": {
+						"for": "$i",
+						"from": 0,
+						"to": 10,
+						"do": {
+							"command": {
+								"symbol": "==",
+								"args": ["$i", 5]
+							}
+						}
+					}
+				}`,
+			expected: []token.Token{
+				{Type: token.LBRACE, Literal: "{"},
+				{Type: token.DOUBLE_QUOTE, Literal: "\""},
+				{Type: token.LOOP, Literal: "loop"},
+				{Type: token.DOUBLE_QUOTE, Literal: "\""},
+				{Type: token.COLON, Literal: ":"},
+				{Type: token.LBRACE, Literal: "{"},
+				{Type: token.DOUBLE_QUOTE, Literal: "\""},
+				{Type: token.FOR, Literal: "for"},
+				{Type: token.DOUBLE_QUOTE, Literal: "\""},
+				{Type: token.COLON, Literal: ":"},
+				{Type: token.DOUBLE_QUOTE, Literal: "\""},
+				{Type: token.SYMBOL, Literal: "$i"},
+				{Type: token.DOUBLE_QUOTE, Literal: "\""},
+				{Type: token.COMMA, Literal: ","},
+				{Type: token.DOUBLE_QUOTE, Literal: "\""},
+				{Type: token.FROM, Literal: "from"},
+				{Type: token.DOUBLE_QUOTE, Literal: "\""},
+				{Type: token.COLON, Literal: ":"},
+				{Type: token.INT, Literal: "0"},
+				{Type: token.COMMA, Literal: ","},
+				{Type: token.DOUBLE_QUOTE, Literal: "\""},
+				{Type: token.TO, Literal: "to"},
+				{Type: token.DOUBLE_QUOTE, Literal: "\""},
+				{Type: token.COLON, Literal: ":"},
+				{Type: token.INT, Literal: "10"},
+				{Type: token.COMMA, Literal: ","},
+				{Type: token.DOUBLE_QUOTE, Literal: "\""},
+				{Type: token.DO, Literal: "do"},
+				{Type: token.DOUBLE_QUOTE, Literal: "\""},
+				{Type: token.COLON, Literal: ":"},
+				{Type: token.LBRACE, Literal: "{"},
+				{Type: token.DOUBLE_QUOTE, Literal: "\""},
+				{Type: token.COMMAND, Literal: "command"},
+				{Type: token.DOUBLE_QUOTE, Literal: "\""},
+				{Type: token.COLON, Literal: ":"},
+				{Type: token.LBRACE, Literal: "{"},
+				{Type: token.DOUBLE_QUOTE, Literal: "\""},
+				{Type: token.SYMBOLKEY, Literal: "symbol"},
+				{Type: token.DOUBLE_QUOTE, Literal: "\""},
+				{Type: token.COLON, Literal: ":"},
+				{Type: token.DOUBLE_QUOTE, Literal: "\""},
+				{Type: token.EQ, Literal: "=="},
+				{Type: token.DOUBLE_QUOTE, Literal: "\""},
+				{Type: token.COMMA, Literal: ","},
+				{Type: token.DOUBLE_QUOTE, Literal: "\""},
+				{Type: token.ARGS, Literal: "args"},
+				{Type: token.DOUBLE_QUOTE, Literal: "\""},
+				{Type: token.COLON, Literal: ":"},
+				{Type: token.LBRACKET, Literal: "["},
+				{Type: token.DOUBLE_QUOTE, Literal: "\""},
+				{Type: token.SYMBOL, Literal: "$i"},
+				{Type: token.DOUBLE_QUOTE, Literal: "\""},
+				{Type: token.COMMA, Literal: ","},
+				{Type: token.INT, Literal: "5"},
+				{Type: token.RBRACKET, Literal: "]"},
+				{Type: token.RBRACE, Literal: "}"},
+				{Type: token.RBRACE, Literal: "}"},
+				{Type: token.RBRACE, Literal: "}"},
+				{Type: token.RBRACE, Literal: "}"},
+				{Type: token.EOF, Literal: ""},
+			},
+		},
 	}
 
 	for _, tt := range tests {

parser/parser.go

@@ -110,6 +110,8 @@ func (p *Parser) parseObject() (obj ast.Expression, err error) {
 		obj, err = p.parseIfExpression()
 	case token.SET:
 		obj, err = p.parseSetExpression()
+	case token.LOOP:
+		obj, err = p.parseLoopExpression()
 	default:
 		err = fmt.Errorf("unexpected token type %s", p.curToken.Type)
 	}
@@ -324,6 +326,106 @@ func (p *Parser) parseSetExpression() (*ast.SetExpression, error) {
 	}, nil
 }
 
+func (p *Parser) parseLoopExpression() (*ast.LoopExpression, error) {
+	loopExpToken, err := p.expectQuotedToken(token.LOOP)
+	if err != nil {
+		return nil, err
+	}
+
+	// skip to for
+	if err := p.expectTokens(
+		token.COLON,
+		token.LBRACE,
+		token.DOUBLE_QUOTE,
+		token.FOR,
+		token.DOUBLE_QUOTE,
+		token.COLON,
+	); err != nil {
+		return nil, err
+	}
+
+	// parse for
+	parsedIndex, err := p.parseExpression()
+	if err != nil {
+		return nil, err
+	}
+	index, ok := parsedIndex.(*ast.Symbol)
+	if !ok {
+		return nil, fmt.Errorf("expected symbol, got %T", parsedIndex)
+	}
+
+	// skip to from
+	if err := p.expectTokens(
+		token.COMMA,
+		token.DOUBLE_QUOTE,
+		token.FROM,
+		token.DOUBLE_QUOTE,
+		token.COLON,
+	); err != nil {
+		return nil, err
+	}
+
+	// parse from
+	parsedFrom, err := p.parseExpression()
+	if err != nil {
+		return nil, err
+	}
+	from, ok := parsedFrom.(*ast.IntegerLiteral)
+	if !ok {
+		return nil, fmt.Errorf("expected integer, got %T", parsedFrom)
+	}
+
+	// skip to to
+	if err := p.expectTokens(
+		token.COMMA,
+		token.DOUBLE_QUOTE,
+		token.TO,
+		token.DOUBLE_QUOTE,
+		token.COLON,
+	); err != nil {
+		return nil, err
+	}
+
+	// parse to
+	parsedTo, err := p.parseExpression()
+	if err != nil {
+		return nil, err
+	}
+	to, ok := parsedTo.(*ast.IntegerLiteral)
+	if !ok {
+		return nil, fmt.Errorf("expected integer, got %T", parsedTo)
+	}
+
+	// skip to do
+	if err := p.expectTokens(
+		token.COMMA,
+		token.DOUBLE_QUOTE,
+		token.DO,
+		token.DOUBLE_QUOTE,
+		token.COLON,
+	); err != nil {
+		return nil, err
+	}
+
+	// parse do
+	body, err := p.parseExpression()
+	if err != nil {
+		return nil, err
+	}
+
+	if err := p.expectTokens(token.RBRACE); err != nil {
+		return nil, err
+	}
+
+	return &ast.LoopExpression{
+		Token: loopExpToken,
+		Index: index,
+		From:  from,
+		To:    to,
+		Body:  body,
+	}, nil
+}
+
 func (p *Parser) parseAtom() (ast.Expression, error) {
 	switch p.curToken.Type {
 	case token.MINUS: