keisan 0.8.11 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 982db21218a4096daa15314fb7de88f1710e1a82be5b122c1b1c4a76323fb44a
-  data.tar.gz: 4df1eec9b4afd5da69db4a6d40d6900dc4bd9bd249dd1b67646766ba8468fd36
+  metadata.gz: 11f1a2644fbb02817db69dd289564d6fdb9bfd09d294cda62b07156723aebc0e
+  data.tar.gz: 4b9787c0d558af15d466759e40fe4cfac35131d254d227416144588256e5ea9f
 SHA512:
-  metadata.gz: bcc26f352e4f13139a9f0e2c0e1e97be8b3801ca6c2590349aad746fb1283776bf14d4f8ff4eb98049dfd624e7d1b71ce5be5770080f3187a4349c01a5fba4a6
-  data.tar.gz: 70e240222845d98e231ceb577939a37020b03ba1e3a5b9b88165a3c62ce4ffb6d5aa16cff0d4d2eed3078746b4595d3e104a2545b09f55f6d5b784dba1307bf1
+  metadata.gz: 8149fee69d598164334b96f8be59b9763168af97e3803c9abea7285da5ed1d90bb9f87710a3de94498461baec65db335168f8e721fe73c4a837c684a30bc4114
+  data.tar.gz: 8a4e301fb14461b164bf0331684fe7ebe3cd660d4abd38f3c44aba5f50fbed58b6b945082accdf13f9da55bcb76579890fd63db75e8b17e5c098c52d0e2d80ae

data/README.md

@@ -64,6 +64,36 @@ ast.children.map(&:to_s)
 #=> ["x**2", "1"]
 ```
 
+#### Caching AST results
+
+Computing the AST from a string takes some non-zero amount of time.
+For applications of this gem that evaluate some set of fixed expressions (possibly with different variable values, but with fixed ASTs), it might be worthwhile to cache the ASTs for faster computation.
+To accomplish this, you can use the `Keisan::AST::Cache` class.
+Passing an instance of this class into the `Calculator` will mean everytime a new expression is encountered it will compute the AST and store it in this cache for retrieval next time the expression is encountered.
+
+```ruby
+cache = Keisan::AST::Cache.new
+# Note: if you don't want to create the Cache instance, you can just pass `cache: true` here as well
+calculator = Keisan::Calculator.new(cache: cache)
+calculator.evaluate("exp(-x/T)", x: 1.0, T: 10)
+#=> 0.9048374180359595
+# This call will use the cached AST for "exp(-x/T)"
+calculator.evaluate("exp(-x/T)", x: 2.0, T: 10)
+#=> 0.8187307530779818
+```
+
+If you just want to pre-populate the cache with some predetermined values, you can call `#fetch_or_build` on the `Cache` for each instance, `freeze` the cache, then use this frozen cache in your calculator.
+A cache that has been frozen will only fetch from the cache, never write new values to it.
+
+```ruby
+cache = Keisan::AST::Cache.new
+cache.fetch_or_build("f(x) + diff(g(x), x)")
+cache.freeze
+# This calculator will never write new values to the cache, but when
+# evaluating `"f(x) + diff(g(x), x)"` will fetch this cached AST.
+calculator = Keisan::Calculator.new(cache: cache)
+```
+
 ##### Specifying variables
 
 Passing in a hash of variable (`name`, `value`) pairs to the `evaluate` method is one way of defining variables
@@ -250,6 +280,14 @@ calculator.evaluate("range(5,10)")
 #=> [5,6,7,8,9]
 calculator.evaluate("range(0,10,2)")
 #=> [0,2,4,6,8]
+calculator.evaluate("[1, 2, 2, 3].uniq")
+#=> [1,2,3]
+calculator.evaluate("[1, 2, 3].difference([2, 3, 4])")
+#=> [1]
+calculator.evaluate("[1, 2, 3].intersection([2, 3, 4])")
+#=> [2, 3]
+calculator.evaluate("[1, 2, 3].union([2, 3, 4])")
+#=> [1, 2, 3, 4]
 ```
 
 ##### Hashes

data/lib/keisan/ast/cache.rb

@@ -0,0 +1,31 @@
+module Keisan
+  module AST
+    class Cache
+      def initialize
+        @cache = {}
+      end
+
+      def fetch_or_build(string)
+        return @cache[string] if @cache.has_key?(string)
+
+        build_from_scratch(string).tap do |ast|
+          unless frozen?
+            # Freeze the AST to keep it from changing in the cache
+            ast.freeze
+            @cache[string] = ast
+          end
+        end
+      end
+
+      def has_key?(string)
+        @cache.has_key?(string)
+      end
+
+      private
+
+      def build_from_scratch(string)
+        Builder.new(string: string).ast
+      end
+    end
+  end
+end

data/lib/keisan/ast/cell.rb

@@ -66,7 +66,7 @@ module Keisan
       end
 
       def to_cell
-        self.class.new(node.to_cell)
+        self.class.new(node.to_node)
       end
 
       def to_s

data/lib/keisan/ast/constant_literal.rb

@@ -22,6 +22,170 @@ module Keisan
           value.to_s
         end
       end
+
+      def is_constant?
+        true
+      end
+
+      def +(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot add #{self.class} to #{other.class}")
+        else
+          super
+        end
+      end
+
+      def -(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot subtract #{self.class} from #{other.class}")
+        else
+          super
+        end
+      end
+
+      def *(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot multiply #{self.class} and #{other.class}")
+        else
+          super
+        end
+      end
+
+      def /(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot divide #{self.class} and #{other.class}")
+        else
+          super
+        end
+      end
+
+      def %(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot modulo #{self.class} and #{other.class}")
+        else
+          super
+        end
+      end
+
+      def !
+        raise Keisan::Exceptions::InvalidExpression.new("Cannot take logical not of #{self.class}")
+      end
+
+      def ~
+        raise Keisan::Exceptions::InvalidExpression.new("Cannot take bitwise not of #{self.class}")
+      end
+
+      def +@
+        raise Keisan::Exceptions::InvalidExpression.new("Cannot take unary plus of #{self.class}")
+      end
+
+      def -@
+        raise Keisan::Exceptions::InvalidExpression.new("Cannot take unary minus of #{self.class}")
+      end
+
+      def **(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot exponentiate #{self.class} and #{other.class}")
+        else
+          super
+        end
+      end
+
+      def &(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot bitwise and #{self.class} and #{other.class}")
+        else
+          super
+        end
+      end
+
+      def ^(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot bitwise xor #{self.class} and #{other.class}")
+        else
+          super
+        end
+      end
+
+      def |(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot bitwise or #{self.class} and #{other.class}")
+        else
+          super
+        end
+      end
+
+      def <<(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot bitwise left shift #{self.class} and #{other.class}")
+        else
+          super
+        end
+      end
+
+      def >>(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot bitwise right shift #{self.class} and #{other.class}")
+        else
+          super
+        end
+      end
+
+      def >(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot compute #{self.class} > #{other.class}")
+        else
+          super
+        end
+      end
+
+      def >=(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot compute #{self.class} >= #{other.class}")
+        else
+          super
+        end
+      end
+
+      def <(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot compute #{self.class} < #{other.class}")
+        else
+          super
+        end
+      end
+
+      def <=(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot compute #{self.class} <= #{other.class}")
+        else
+          super
+        end
+      end
+
+      def equal(other)
+        other.is_constant? ? Boolean.new(false) : super
+      end
+
+      def not_equal(other)
+        other.is_constant? ? Boolean.new(true) : super
+      end
+
+      def and(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot logical and #{self.class} and #{other.class}")
+        else
+          super
+        end
+      end
+
+      def or(other)
+        if other.is_constant?
+          raise Keisan::Exceptions::InvalidExpression.new("Cannot logical or #{self.class} and #{other.class}")
+        else
+          super
+        end
+      end
     end
   end
 end

data/lib/keisan/ast/function.rb

@@ -91,6 +91,13 @@ module Keisan
 
         self.class.new([self, variable], "diff")
       end
+
+      # Functions cannot be guaranteed to be constant even if the arguments
+      # are constants, because there might be randomness involved in the
+      # outputs.
+      def is_constant?
+        false
+      end
     end
   end
 end

data/lib/keisan/ast/hash.rb

@@ -90,6 +90,10 @@ module Keisan
         ])
         AST::Cell.new(h)
       end
+
+      def is_constant?
+        @hash.all? {|k,v| v.is_constant?}
+      end
     end
   end
 end

data/lib/keisan/ast/indexing.rb

@@ -8,6 +8,19 @@ module Keisan
         @indexes = indexes
       end
 
+      def deep_dup
+        dupped = super
+        dupped.instance_variable_set(
+          :@indexes, indexes.map(&:deep_dup)
+        )
+        dupped
+      end
+
+      def freeze
+        indexes.each(&:freeze)
+        super
+      end
+
       def value(context = nil)
         return child.value(context).send(:[], *indexes.map {|index| index.value(context)})
       end

data/lib/keisan/ast/logical_and.rb

@@ -26,7 +26,7 @@ module Keisan
 
       def short_circuit_do(method, context)
         context ||= Context.new
-        lhs = children[0].send(method, context)
+        lhs = children[0].send(method, context).to_node
         case lhs
         when AST::Boolean
           lhs.false? ? AST::Boolean.new(false) : children[1].send(method, context)

data/lib/keisan/ast/logical_or.rb

@@ -26,7 +26,7 @@ module Keisan
 
       def short_circuit_do(method, context)
         context ||= Context.new
-        lhs = children[0].send(method, context)
+        lhs = children[0].send(method, context).to_node
         case lhs
         when AST::Boolean
           lhs.true? ? AST::Boolean.new(true) : children[1].send(method, context)

data/lib/keisan/ast/node.rb

@@ -202,6 +202,10 @@ module Keisan
       def or(other)
         LogicalOr.new([self, other.to_node])
       end
+
+      def is_constant?
+        false
+      end
     end
   end
 end

data/lib/keisan/ast/operator.rb

@@ -45,8 +45,6 @@ module Keisan
 
         children = Array(children)
         super(children)
-
-        @parsing_operators = parsing_operators
       end
 
       def evaluate_assignments(context = nil)

data/lib/keisan/ast/parent.rb

@@ -75,6 +75,10 @@ module Keisan
         @children = children.map {|child| child.replace(variable, replacement)}
         self
       end
+
+      def is_constant?
+        @children.all?(&:is_constant?)
+      end
     end
   end
 end

data/lib/keisan/ast/plus.rb

@@ -3,7 +3,7 @@ module Keisan
     class Plus < ArithmeticOperator
       def initialize(children = [], parsing_operators = [])
         super
-        convert_minus_to_plus!
+        convert_minus_to_plus!(parsing_operators)
       end
 
       def self.symbol
@@ -87,8 +87,8 @@ module Keisan
         date_time + others.inject(0, &:+)
       end
 
-      def convert_minus_to_plus!
-        @parsing_operators.each.with_index do |parsing_operator, index|
+      def convert_minus_to_plus!(parsing_operators)
+        parsing_operators.each.with_index do |parsing_operator, index|
           if parsing_operator.is_a?(Parsing::Minus)
             @children[index+1] = UnaryMinus.new(@children[index+1])
           end

data/lib/keisan/ast/times.rb

@@ -3,7 +3,7 @@ module Keisan
     class Times < ArithmeticOperator
       def initialize(children = [], parsing_operators = [])
         super
-        convert_divide_to_inverse!
+        convert_divide_to_inverse!(parsing_operators)
       end
 
       def self.symbol
@@ -63,8 +63,8 @@ module Keisan
 
       private
 
-      def convert_divide_to_inverse!
-        @parsing_operators.each.with_index do |parsing_operator, index|
+      def convert_divide_to_inverse!(parsing_operators)
+        parsing_operators.each.with_index do |parsing_operator, index|
           if parsing_operator.is_a?(Parsing::Divide)
             @children[index+1] = UnaryInverse.new(@children[index+1])
           end

data/lib/keisan/ast/unary_logical_not.rb

@@ -8,6 +8,32 @@ module Keisan
       def self.symbol
         :"!"
       end
+
+      def evaluate(context = nil)
+        context ||= Context.new
+        node = child.evaluate(context).to_node
+        case node
+        when AST::Boolean
+          AST::Boolean.new(!node.value)
+        else
+          if node.is_constant?
+            raise Keisan::Exceptions::InvalidFunctionError.new("Cannot take unary logical not of non-boolean constant")
+          else
+            super
+          end
+        end
+      end
+
+      def simplify(context = nil)
+        context ||= Context.new
+        node = child.simplify(context).to_node
+        case node
+        when AST::Boolean
+          AST::Boolean.new(!node.value)
+        else
+          super
+        end
+      end
     end
   end
 end

data/lib/keisan/calculator.rb

@@ -4,13 +4,23 @@ module Keisan
 
     # Note, allow_recursive would be more appropriately named:
     # allow_unbound_functions_in_function_definitions, but it is too late for that.
-    def initialize(context: nil, allow_recursive: false, allow_blocks: true, allow_multiline: true, allow_random: true)
+    def initialize(context: nil, allow_recursive: false, allow_blocks: true, allow_multiline: true, allow_random: true, cache: nil)
       @context = context || Context.new(
         allow_recursive: allow_recursive,
         allow_blocks: allow_blocks,
         allow_multiline: allow_multiline,
         allow_random: allow_random
       )
+      @cache = case cache
+               when nil, false
+                 nil
+               when true
+                 AST::Cache.new
+               when AST::Cache
+                 cache
+               else
+                 raise Exceptions::StandardError.new("cache must be either nil, false, true, or an instance of Keisan::AST::Cache")
+               end
     end
 
     def allow_recursive
@@ -34,15 +44,23 @@ module Keisan
     end
 
     def evaluate(expression, definitions = {})
-      Evaluator.new(self).evaluate(expression, definitions)
+      Evaluator.new(self, cache: @cache).evaluate(expression, definitions)
+    end
+
+    def evaluate_ast(ast, definitions = {})
+      Evaluator.new(self, cache: @cache).evaluate_ast(ast, definitions: definitions)
     end
 
     def simplify(expression, definitions = {})
-      Evaluator.new(self).simplify(expression, definitions)
+      Evaluator.new(self, cache: @cache).simplify(expression, definitions)
+    end
+
+    def simplify_ast(ast, definitions = {})
+      Evaluator.new(self, cache: @cache).simplify_ast(ast, definitions: definitions)
     end
 
     def ast(expression)
-      Evaluator.new(self).parse_ast(expression)
+      Evaluator.new(self, cache: @cache).parse_ast(expression)
     end
 
     def define_variable!(name, value)

data/lib/keisan/evaluator.rb

@@ -2,13 +2,18 @@ module Keisan
   class Evaluator
     attr_reader :calculator
 
-    def initialize(calculator)
+    def initialize(calculator, cache: nil)
       @calculator = calculator
+      @cache = cache
     end
 
     def evaluate(expression, definitions = {})
       context = calculator.context.spawn_child(definitions: definitions, transient: true)
-      ast = parse_ast(expression)
+      evaluate_ast(parse_ast(expression), context: context)
+    end
+
+    def evaluate_ast(ast, definitions: {}, context: nil)
+      context ||= calculator.context.spawn_child(definitions: definitions, transient: true)
       last_line = last_line(ast)
 
       evaluation = ast.evaluated(context)
@@ -24,17 +29,21 @@ module Keisan
 
     def simplify(expression, definitions = {})
       context = calculator.context.spawn_child(definitions: definitions, transient: true)
-      ast = parse_ast(expression)
-      ast.simplify(context)
+      simplify_ast(parse_ast(expression), context: context)
+    end
+
+    def simplify_ast(ast, definitions: {}, context: nil)
+      context ||= calculator.context.spawn_child(definitions: definitions, transient: true)
+      ast.simplified(context)
     end
 
     def parse_ast(expression)
-      AST.parse(expression).tap do |ast|
-        disallowed = disallowed_nodes
-        if !disallowed.empty? && ast.contains_a?(disallowed)
-          raise Keisan::Exceptions::InvalidExpression.new("Context does not permit expressions with #{disallowed}")
-        end
+      ast = @cache.nil? ? AST.parse(expression) : @cache.fetch_or_build(expression)
+      disallowed = disallowed_nodes
+      if !disallowed.empty? && ast.contains_a?(disallowed)
+        raise Keisan::Exceptions::InvalidExpression.new("Context does not permit expressions with #{disallowed}")
       end
+      ast
     end
 
     private

data/lib/keisan/functions/default_registry.rb

@@ -118,10 +118,13 @@ module Keisan
       end
 
       def self.register_array_methods!(registry)
-        %i(min max size flatten reverse).each do |method|
+        %i(min max size flatten reverse uniq).each do |method|
           registry.register!(method, Proc.new {|a| a.send(method)}, force: true)
         end
 
+        registry.register!(:difference, Proc.new {|a, b| a - b}, force: true)
+        registry.register!(:intersection, Proc.new {|a, b| a & b}, force: true)
+        registry.register!(:union, Proc.new {|a, b| a | b}, force: true)
         registry.register!("range", Functions::Range.new, force: true)
       end
 

data/lib/keisan/functions/enumerable_function.rb

@@ -21,7 +21,7 @@ module Keisan
         context ||= Context.new
 
         operand, arguments, expression = operand_arguments_expression_for(ast_function, context)
-        
+
         # Extract underlying operand for cells
         real_operand = operand.is_a?(AST::Cell) ? operand.node : operand
 
@@ -54,7 +54,7 @@ module Keisan
       private
 
       def operand_arguments_expression_for(ast_function, context)
-        operand = ast_function.children[0].simplify(context)
+        operand = ast_function.children[0].evaluate(context)
         arguments = ast_function.children[1...-1]
         expression = ast_function.children[-1]
 

data/lib/keisan/functions/expression_function.rb

@@ -14,6 +14,12 @@ module Keisan
         @transient_definitions = transient_definitions
       end
 
+      def freeze
+        @arguments.freeze
+        @expression.freeze
+        super
+      end
+
       def call(context, *args)
         validate_arguments!(args.count)
 
@@ -96,7 +102,7 @@ module Keisan
       private
 
       def argument_variables
-        @argument_variables ||= arguments.map {|argument| AST::Variable.new(argument)}
+        arguments.map {|argument| AST::Variable.new(argument)}
       end
 
       def calculate_partial_derivatives(context)

data/lib/keisan/functions/filter.rb

@@ -29,7 +29,7 @@ module Keisan
         AST::List.new(
           list.children.select do |element|
             local.register_variable!(variable, element)
-            result = expression.evaluated(local)
+            result = expression.evaluated(local).to_node
 
             case result
             when AST::Boolean
@@ -54,7 +54,7 @@ module Keisan
           hash.select do |cur_key, cur_value|
             local.register_variable!(key, cur_key)
             local.register_variable!(value, cur_value)
-            result = expression.evaluated(local)
+            result = expression.evaluated(local).to_node
 
             case result
             when AST::Boolean

data/lib/keisan/functions/if.rb

@@ -13,12 +13,13 @@ module Keisan
       def evaluate(ast_function, context = nil)
         validate_arguments!(ast_function.children.count)
         context ||= Context.new
-
-        bool = ast_function.children[0].evaluate(context)
+        bool = ast_function.children[0].evaluate(context).to_node
 
         if bool.is_a?(AST::Boolean)
           node = bool.value ? ast_function.children[1] : ast_function.children[2]
           node.to_node.evaluate(context)
+        elsif bool.is_constant?
+          raise Keisan::Exceptions::InvalidFunctionError.new("if statement must work on booleans, other constants are not supported")
         else
           ast_function
         end
@@ -27,7 +28,7 @@ module Keisan
       def simplify(ast_function, context = nil)
         validate_arguments!(ast_function.children.count)
         context ||= Context.new
-        bool = ast_function.children[0].simplify(context)
+        bool = ast_function.children[0].simplify(context).to_node
 
         if bool.is_a?(AST::Boolean)
           if bool.value
@@ -37,6 +38,8 @@ module Keisan
           else
             Keisan::AST::Null.new
           end
+        elsif bool.is_constant?
+          raise Keisan::Exceptions::InvalidFunctionError.new("if statement must work on booleans, other constants are not supported")
         else
           ast_function
         end

data/lib/keisan/functions/registry.rb

@@ -44,6 +44,9 @@ module Keisan
         when Proc
           self[name] = ProcFunction.new(name, function)
         when Function
+          # The expression AST which represents the function should be constant,
+          # so we freeze it so it will always have the same behavior.
+          function.freeze if function.is_a?(ExpressionFunction)
           self[name] = function
         else
           raise Exceptions::InvalidFunctionError.new

data/lib/keisan/functions/while.rb

@@ -1,6 +1,9 @@
 module Keisan
   module Functions
     class While < Keisan::Function
+      class WhileLogicalNodeIsNotConstant < Keisan::Exceptions::StandardError; end
+      class WhileLogicalNodeIsNonBoolConstant < Keisan::Exceptions::StandardError; end
+
       def initialize
         super("while", 2)
       end
@@ -13,27 +16,43 @@ module Keisan
       def evaluate(ast_function, context = nil)
         validate_arguments!(ast_function.children.count)
         context ||= Keisan::Context.new
-        simplify(ast_function, context)
+        while_loop(ast_function, context, simplify: false)
       end
 
       def simplify(ast_function, context = nil)
         validate_arguments!(ast_function.children.count)
         context ||= Context.new
-        while_loop(ast_function.children[0], ast_function.children[1], context)
+        while_loop(ast_function, context, simplify: true)
       end
 
       private
 
-      def while_loop(logical_node, body_node, context)
+      def while_loop(ast_function, context, simplify: true)
+        logical_node, body_node = ast_function.children[0], ast_function.children[1]
         current = Keisan::AST::Null.new
 
-        while logical_node_evaluates_to_true(logical_node, context)
-          begin
-            current = body_node.evaluated(context)
-          rescue Exceptions::BreakError
-            break
-          rescue Exceptions::ContinueError
-            next
+        begin
+          while logical_node_evaluates_to_true(logical_node, context)
+            begin
+              current = body_node.evaluated(context)
+            rescue Exceptions::BreakError
+              break
+            rescue Exceptions::ContinueError
+              next
+            end
+          end
+
+        # While loops should work on booleans, not other types of constants
+        rescue WhileLogicalNodeIsNonBoolConstant
+          raise Keisan::Exceptions::InvalidFunctionError.new("while condition must evaluate to a boolean")
+
+        # If the logical expression is not constant (e.g. boolean), then we
+        # cannot simplify the while loop, and an evaluate should raise an error.
+        rescue WhileLogicalNodeIsNotConstant
+          if simplify
+            return ast_function
+          else
+            raise Keisan::Exceptions::InvalidFunctionError.new("while condition must evaluate to a boolean")
           end
         end
 
@@ -41,11 +60,15 @@ module Keisan
       end
 
       def logical_node_evaluates_to_true(logical_node, context)
-        bool = logical_node.evaluated(context)
-        unless bool.is_a?(AST::Boolean)
-          raise Keisan::Exceptions::InvalidFunctionError.new("while condition must evaluate to a boolean")
+        bool = logical_node.evaluated(context).to_node
+
+        if bool.is_a?(AST::Boolean)
+          bool.value(context)
+        elsif bool.is_constant?
+          raise WhileLogicalNodeIsNonBoolConstant.new
+        else
+          raise WhileLogicalNodeIsNotConstant.new
         end
-        bool.value(context)
       end
     end
   end

data/lib/keisan/parser.rb

@@ -211,7 +211,8 @@ module Keisan
       when :square
         @components << Parsing::List.new(arguments_from_group(token))
       when :curly
-        if token.sub_tokens.any? {|token| token.is_a?(Tokens::Colon)}
+        # A hash either has a colon, or is empty
+        if token.sub_tokens.any? {|token| token.is_a?(Tokens::Colon)} || token.sub_tokens.empty?
           @components << Parsing::Hash.new(Util.array_split(token.sub_tokens) {|token| token.is_a?(Tokens::Comma)})
         else
           @components << Parsing::CurlyGroup.new(token.sub_tokens)

data/lib/keisan/parsing/hash.rb

@@ -4,15 +4,25 @@ module Keisan
       attr_reader :key_value_pairs
 
       def initialize(key_value_pairs)
-        @key_value_pairs = Array(key_value_pairs).map {|key_value_pair|
-          validate_and_extract_key_value_pair(key_value_pair)
-        }
+        key_value_pairs = Array(key_value_pairs)
+        if key_value_pairs.size == 1 && key_value_pairs.first.empty?
+          @key_value_pairs = []
+        else
+          @key_value_pairs = key_value_pairs.map {|key_value_pair|
+            validate_and_extract_key_value_pair(key_value_pair)
+          }
+        end
       end
 
       private
 
       def validate_and_extract_key_value_pair(key_value_pair)
-        key, value = Util.array_split(key_value_pair) {|token| token.is_a?(Tokens::Colon)}
+        filtered_key_value_pair = key_value_pair.select {|token|
+          !token.is_a?(Tokens::LineSeparator)
+        }
+        key, value = Util.array_split(filtered_key_value_pair) {|token|
+          token.is_a?(Tokens::Colon)
+        }
         raise Exceptions::ParseError.new("Invalid hash") unless key.size == 1 && value.size >= 1
 
         key = key.first

data/lib/keisan/version.rb

@@ -1,3 +1,3 @@
 module Keisan
-  VERSION = "0.8.11"
+  VERSION = "0.9.1"
 end

data/lib/keisan.rb

@@ -55,6 +55,7 @@ require "keisan/ast/indexing"
 
 require "keisan/ast/line_builder"
 require "keisan/ast/builder"
+require "keisan/ast/cache"
 require "keisan/ast"
 
 require "keisan/function"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: keisan
 version: !ruby/object:Gem::Version
-  version: 0.8.11
+  version: 0.9.1
 platform: ruby
 authors:
 - Christopher Locke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-20 00:00:00.000000000 Z
+date: 2021-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmath
@@ -139,6 +139,7 @@ files:
 - lib/keisan/ast/block.rb
 - lib/keisan/ast/boolean.rb
 - lib/keisan/ast/builder.rb
+- lib/keisan/ast/cache.rb
 - lib/keisan/ast/cell.rb
 - lib/keisan/ast/cell_assignment.rb
 - lib/keisan/ast/constant_literal.rb