Merge efa385b into a4a9a1a

README.md

@@ -326,12 +326,16 @@ calculator.evaluate("2 + if(1 > 0, 10, 29)")
 ```
 
 For looping, you can use the basic `while` loop, which has an expression that evaluates to a boolean as the first argument, and any expression in the second argument.
+One can use the keywords `break` and `continue` to control loop flow as well.
 
 ```ruby
 calculator = Keisan::Calculator.new
 calculator.evaluate("my_sum(a) = {let i = 0; let total = 0; while(i < a.size, {total += a[i]; i += 1}); total}")
 calculator.evaluate("my_sum([1,3,5,7,9])")
 #=> 25
+calculator.evaluate("has_element(a, x) = {let i=0; let found=false; while(i<a.size, if(a[i] == x, found = true; break); i+=1); found}")
+calculator.evaluate("[2, 3, 7, 11].has_element(11)")
+#=> true
 ```
 
 ##### Bitwise operations

lib/keisan/exceptions.rb

@@ -18,5 +18,8 @@ class UnmodifiableError < StandardError; end
     class InvalidExpression < StandardError; end
     class TypeError < StandardError; end
     class NonDifferentiableError < StandardError; end
+
+    class BreakError < StandardError; end
+    class ContinueError < StandardError; end
   end
 end

lib/keisan/functions/break.rb

@@ -0,0 +1,11 @@
+require_relative "loop_control_flow_function"
+
+module Keisan
+  module Functions
+    class Break < LoopControlFlowFuntion
+      def initialize
+        super("break", Exceptions::BreakError)
+      end
+    end
+  end
+end

lib/keisan/functions/continue.rb

@@ -0,0 +1,11 @@
+require_relative "loop_control_flow_function"
+
+module Keisan
+  module Functions
+    class Continue < LoopControlFlowFuntion
+      def initialize
+        super("continue", Exceptions::ContinueError)
+      end
+    end
+  end
+end

lib/keisan/functions/default_registry.rb

@@ -1,5 +1,7 @@
 require_relative "let"
 require_relative "puts"
+require_relative "break"
+require_relative "continue"
 
 require_relative "if"
 require_relative "while"
@@ -49,6 +51,8 @@ def self.registry
       def self.register_defaults!(registry)
         registry.register!(:let, Let.new, force: true)
         registry.register!(:puts, Puts.new, force: true)
+        registry.register!(:break, Break.new, force: true)
+        registry.register!(:continue, Continue.new, force: true)
 
         registry.register!(:if, If.new, force: true)
         registry.register!(:while, While.new, force: true)

lib/keisan/functions/loop_control_flow_function.rb

@@ -0,0 +1,22 @@
+module Keisan
+  module Functions
+    class LoopControlFlowFuntion < Function
+      def initialize(name, exception_class)
+        super(name, 0)
+        @exception_class = exception_class
+      end
+
+      def value(ast_function, context = nil)
+        raise @exception_class.new
+      end
+
+      def evaluate(ast_function, context = nil)
+        raise @exception_class.new
+      end
+
+      def simplify(ast_function, context = nil)
+        raise @exception_class.new
+      end
+    end
+  end
+end

lib/keisan/functions/while.rb

@@ -28,7 +28,13 @@ def while_loop(logical_node, body_node, context)
         current = Keisan::AST::Null.new
 
         while logical_node_evaluates_to_true(logical_node, context)
-          current = body_node.evaluated(context)
+          begin
+            current = body_node.evaluated(context)
+          rescue Exceptions::BreakError
+            break
+          rescue Exceptions::ContinueError
+            next
+          end
         end
 
         current

lib/keisan/parser.rb

@@ -1,6 +1,6 @@
 module Keisan
   class Parser
-    KEYWORDS = %w(let puts).freeze
+    KEYWORDS = %w(let puts break continue).freeze
 
     attr_reader :tokens, :components
 

spec/keisan/default_functions_spec.rb

@@ -226,4 +226,22 @@
       expect(calculator.simplify("diff(cbrt(2*x), x)").to_s).to eq "(2/3)*((2*x)**(-2/3))"
     end
   end
+
+  context "loop control flow keywords" do
+    describe "break" do
+      it "immediately ends the loop" do
+        calculator = Keisan::Calculator.new
+        expect(calculator.evaluate("x = 0; while(true, x += 1; if(x >= 5, break)); x")).to eq 5
+      end
+    end
+
+    describe "continue" do
+      it "skips to the next iteration of the loop" do
+        calculator = Keisan::Calculator.new
+        expect(calculator.evaluate("x = 0; sum = 0; while(x < 10, x += 1; if (x % 2 == 0, continue); sum += x**2); sum")).to eq(
+          1 + 3**2 + 5**2 + 7**2 + 9**2
+        )
+      end
+    end
+  end
 end

spec/keisan/parser_spec.rb

@@ -650,9 +650,14 @@
     end
 
     context "keyword" do
+      it "has these keywords" do
+        expect(described_class::KEYWORDS).to match_array(%w(let puts break continue))
+      end
+
       it "parses the keyword into a function call" do
         parser = described_class.new(string: "let x = 5")
         expect(parser.components.map(&:class)).to eq([Keisan::Parsing::Function])
+        expect(parser.components.first.name).to eq "let"
         expect(parser.components.first.arguments.count).to eq 1
         expect(parser.components.first.arguments.first.components.map(&:class)).to eq([
           Keisan::Parsing::Variable,

spec/readme_spec.rb

@@ -13,7 +13,7 @@
       digest = Digest::SHA256.hexdigest(content)
 
       # cat README.md | sha256sum
-      expected_digest = "c430ca4bd926e553e7414c96f89b8f81ef8bf3c491c5484e9f9599f38e06e2f7"
+      expected_digest = "5cbc6ded4d07c2304325871a0a2181bfc66616b789bc63aa57fc8310592d789d"
       if digest != expected_digest
         raise "Invalid README file detected with SHA256 digest of #{digest}. Use command `cat README.md | sha256sum` to get correct digest if your changes to the README are safe. Aborting README test."
       end