For loops

lib/ahem/ast.rb

@@ -7,6 +7,7 @@ module AST
   require 'ahem/ast/branch'
   require 'ahem/ast/class_definition'
   require 'ahem/ast/conditional'
+  require 'ahem/ast/for_loop'
   require 'ahem/ast/function_call'
   require 'ahem/ast/function_definition'
   require 'ahem/ast/hash'

lib/ahem/ast/for_loop.rb

@@ -0,0 +1,22 @@
+class AST::ForLoop
+  attr_reader :iterator, :iterable, :block
+
+  def initialize(iterator, iterable, block)
+    @iterator = iterator
+    @iterable = iterable
+    @block = block
+  end
+
+  def ==(other)
+    other.is_a?(AST::ForLoop) && other.iterator == @iterator &&
+      other.iterable == @iterable && other.block == @block
+  end
+
+  def execute(env)
+    @iterable.execute(env).each do |i|
+      _env = Environment.new
+      _env.set(@iterator.name, i)
+      @block.execute(_env)
+    end
+  end
+end

lib/ahem/lexer.rb

@@ -127,6 +127,12 @@ class Lexer
     elsif source.match(/^private/)
       @position += 7
       Token.new(TokenKinds::PRIVATE)
+    elsif source.match(/^for/)
+      @position += 3
+      Token.new(TokenKinds::FOR)
+    elsif source.match(/^in/)
+      @position += 2
+      Token.new(TokenKinds::IN)
     elsif source.match(/^[a-z][a-zA-Z0-9_]*/)
       identifier = source.match(/^[a-z][a-zA-Z0-9_]*/)[0]
       @position += identifier.size

lib/ahem/parser.rb

@@ -21,6 +21,8 @@ class Parser
       function_definition
     elsif @current_token.type == TokenKinds::CLASS
       class_definition
+    elsif @current_token.type == TokenKinds::FOR
+      for_loop
     else
       expr = expression
       eat(TokenKinds::SEMICOLON)
@@ -112,6 +114,15 @@ class Parser
     AST::Conditional.new(branches)
   end
 
+  def for_loop
+    eat(TokenKinds::FOR)
+    iterator = identifier
+    eat(TokenKinds::IN)
+    iterable = expression
+    body = block
+    AST::ForLoop.new(iterator, iterable, body)
+  end
+
   def parameters
     params = Array.new
     eat(TokenKinds::LPAREN)

lib/ahem/token_kinds.rb

@@ -9,9 +9,11 @@ module TokenKinds
   ELSE = :else
   EOF = :eof
   EQUALS = :equals
+  FOR = :for
   FUNCTION = :function
   IDENTIFIER = :identifier
   IF = :if
+  IN = :in
   LBRACE = :lbrace
   LBRACKET = :lbracket
   LPAREN = :lparen

spec/ast/for_loop_spec.rb

@@ -0,0 +1,22 @@
+RSpec.describe AST::ForLoop do
+  it 'evaluates' do
+    expect {
+      AST::ForLoop.new(
+        AST::Identifier.new('x'),
+        AST::Array.new(
+          [
+            AST::Number.new(1.0),
+            AST::Number.new(2.0),
+            AST::Number.new(3.0),
+          ]
+        ),
+        AST::FunctionCall.new(
+          AST::Identifier.new('print'),
+          [
+            AST::Identifier.new('x')
+          ]
+        )
+      ).execute(Environment.new)
+    }.to output("1.0\n2.0\n3.0\n").to_stdout
+  end
+end

spec/lexer_spec.rb

@@ -137,4 +137,14 @@ RSpec.describe Lexer do
       ]
     )
   end
+
+  it 'lexes for' do
+    expect(Lexer.new('for in').scan_all).to eq(
+      [
+        Token.new(TokenKinds::FOR),
+        Token.new(TokenKinds::IN),
+        Token.new(TokenKinds::EOF),
+      ]
+    )
+  end
 end

spec/parser_spec.rb

@@ -358,4 +358,25 @@ RSpec.describe Parser do
       ]
     )
   end
+
+  it 'parses for loops' do
+    expect(parse('for x in xs { print(x); }')).to eq(
+      [
+        AST::ForLoop.new(
+          AST::Identifier.new('x'),
+          AST::Identifier.new('xs'),
+          AST::Block.new(
+            [
+              AST::FunctionCall.new(
+                AST::Identifier.new('print'),
+                [
+                  AST::Identifier.new('x')
+                ]
+              )
+            ]
+          )
+        )
+      ]
+    )
+  end
 end