keisan 0.6.0 → 0.7.0

data/lib/keisan/ast/line_builder.rb

@@ -143,6 +143,15 @@ module Keisan
               Builder.new(components: parsing_argument.components).node
             }
           )
+        when Parsing::Hash
+          AST::Hash.new(
+            component.key_value_pairs.map {|key_value_pair|
+              [
+                Builder.new(components: [key_value_pair[0]]).node,
+                Builder.new(components: key_value_pair[1].components).node
+              ]
+            }
+          )
         when Parsing::RoundGroup
           Builder.new(components: component.components).node
         when Parsing::CurlyGroup
@@ -213,10 +222,19 @@ module Keisan
           @nodes.insert(index, replacement_node)
           @priorities.insert(index, -1)
         elsif operator.is_a?(Keisan::Parsing::Operator)
-          replacement_node = operator.node_class.new(
-            children = [@nodes[index-1],@nodes[index+1]],
-            parsing_operators = [operator]
-          )
+          if operator.is_a?(Keisan::Parsing::CompoundAssignment)
+            replacement_node = operator.node_class.new(
+              children = [@nodes[index-1],@nodes[index+1]],
+              parsing_operators = [operator],
+              compound_operator: operator.compound_operator
+            )
+          else
+            replacement_node = operator.node_class.new(
+              children = [@nodes[index-1],@nodes[index+1]],
+              parsing_operators = [operator]
+            )
+          end
+
           @nodes.delete_if.with_index {|node, i| i >= index-1 && i <= index+1}
           @priorities.delete_if.with_index {|node, i| i >= index-1 && i <= index+1}
           @nodes.insert(index-1, replacement_node)

data/lib/keisan/ast/list.rb

@@ -3,21 +3,16 @@ module Keisan
     class List < Parent
       def initialize(children = [])
         super(children)
-        cellify!
       end
 
       def evaluate(context = nil)
         context ||= Context.new
-        super(context)
-        cellify!
+        @children = children.map {|child| child.is_a?(Cell) ? child : child.evaluate(context)}
         self
       end
 
       def simplify(context = nil)
-        context ||= Context.new
-        super(context)
-        cellify!
-        self
+        evaluate(context)
       end
 
       def value(context = nil)
@@ -29,6 +24,18 @@ module Keisan
         "[#{children.map(&:to_s).join(',')}]"
       end
 
+      def to_a
+        @children.map(&:value)
+      end
+
+      def to_cell
+        AST::Cell.new(
+          self.class.new(
+            @children.map(&:to_cell)
+          )
+        )
+      end
+
       private
 
       def cellify!

data/lib/keisan/ast/node.rb

@@ -57,6 +57,19 @@ module Keisan
         self
       end
 
+      def to_cell
+        AST::Cell.new(self)
+      end
+
+      # Will only return False for AST::Boolean(false) and AST::Null
+      def true?
+        true
+      end
+
+      def false?
+        !true?
+      end
+
       def +(other)
         Plus.new(
           [self, other.to_node]

data/lib/keisan/ast/null.rb

@@ -7,6 +7,20 @@ module Keisan
       def value(context = nil)
         nil
       end
+
+      def true?
+        false
+      end
+
+      def equal(other)
+        other = other.to_node
+        other.is_a?(AST::Null) ? Boolean.new(value == other.value) : super
+      end
+
+      def not_equal(other)
+        other = other.to_node
+        other.is_a?(AST::Null) ? Boolean.new(value != other.value) : super
+      end
     end
   end
 end

data/lib/keisan/ast/parent.rb

@@ -4,10 +4,10 @@ module Keisan
       attr_reader :children
 
       def initialize(children = [])
-        children = Array.wrap(children).map(&:to_node)
-        unless children.is_a?(Array) && children.all? {|children| children.is_a?(Node)}
-          raise Exceptions::InternalError.new
+        children = Array.wrap(children).map do |child|
+          child.is_a?(Cell) ? child : child.to_node
         end
+        raise Exceptions::InternalError.new unless children.is_a?(Array)
         @children = children
       end
 
@@ -25,6 +25,11 @@ module Keisan
         end
       end
 
+      def freeze
+        children.each(&:freeze)
+        super
+      end
+
       def ==(other)
         return false unless self.class == other.class
 

data/lib/keisan/ast/string.rb

@@ -27,6 +27,16 @@ module Keisan
           "\"#{value}\""
         end
       end
+
+      def equal(other)
+        other = other.to_node
+        other.is_a?(AST::String) ? Boolean.new(value == other.value) : super
+      end
+
+      def not_equal(other)
+        other = other.to_node
+        other.is_a?(AST::String) ? Boolean.new(value != other.value) : super
+      end
     end
   end
 end

data/lib/keisan/ast/variable.rb

@@ -7,6 +7,10 @@ module Keisan
         @name = name
       end
 
+      def variable_truthy?(context)
+        context.has_variable?(name) && context.variable(name).true?
+      end
+
       def value(context = nil)
         context ||= Context.new
         variable_node_from_context(context).value(context)

data/lib/keisan/ast/variable_assignment.rb

@@ -0,0 +1,62 @@
+module Keisan
+  module AST
+    class VariableAssignment
+      attr_reader :assignment, :context, :lhs, :rhs
+
+      def initialize(assignment, context, lhs, rhs)
+        @assignment = assignment
+        @context = context
+        @lhs = lhs
+        @rhs = rhs
+      end
+
+      def evaluate
+        case assignment.compound_operator
+        when :"||"
+          evaluate_variable_or_assignment(context, lhs, rhs)
+        when :"&&"
+          evaluate_variable_and_assignment(context, lhs, rhs)
+        else
+          evaluate_variable_non_logical_assignment(context, lhs, rhs)
+        end
+      end
+
+      private
+
+      def evaluate_variable_or_assignment(context, lhs, rhs)
+        if lhs.variable_truthy?(context)
+          lhs
+        else
+          rhs = rhs.evaluate(context)
+          context.register_variable!(lhs.name, rhs.value(context))
+          rhs
+        end
+      end
+
+      def evaluate_variable_and_assignment(context, lhs, rhs)
+        if lhs.variable_truthy?(context)
+          rhs = rhs.evaluate(context)
+          context.register_variable!(lhs.name, rhs.value(context))
+          rhs
+        else
+          context.register_variable!(lhs.name, nil) unless context.has_variable?(lhs.name)
+          lhs
+        end
+      end
+
+      def evaluate_variable_non_logical_assignment(context, lhs, rhs)
+        rhs = rhs.evaluate(context)
+        rhs_value = rhs.value(context)
+
+        if assignment.compound_operator
+          raise Exceptions::InvalidExpression.new("Compound assignment requires variable #{lhs.name} to already exist") unless context.has_variable?(lhs.name)
+          rhs_value = context.variable(lhs.name).value.send(assignment.compound_operator, rhs_value)
+        end
+
+        context.register_variable!(lhs.name, rhs_value, local: assignment.local)
+        # Return the variable assigned value
+        rhs
+      end
+    end
+  end
+end

data/lib/keisan/context.rb

@@ -14,6 +14,12 @@ module Keisan
       @allow_recursive = true
     end
 
+    def freeze
+      super
+      @function_registry.freeze
+      @variable_registry.freeze
+    end
+
     # A transient context does not persist variables and functions in this context, but
     # rather store them one level higher in the parent context.  When evaluating a string,
     # the entire operation is done in a transient context that is unique from the calculators
@@ -61,8 +67,12 @@ module Keisan
       @variable_registry.has?(name)
     end
 
+    def variable_is_modifiable?(name)
+      @variable_registry.modifiable?(name)
+    end
+
     def register_variable!(name, value, local: false)
-      if !@variable_registry.shadowed.member?(name) && (transient? || !local && @parent&.has_variable?(name))
+      if !@variable_registry.shadowed.member?(name) && (transient? || !local && @parent&.variable_is_modifiable?(name))
         @parent.register_variable!(name, value)
       else
         @variable_registry.register!(name, value)
@@ -77,8 +87,12 @@ module Keisan
       @function_registry.has?(name)
     end
 
+    def function_is_modifiable?(name)
+      @function_registry.modifiable?(name)
+    end
+
     def register_function!(name, function, local: false)
-      if transient? || !local && @parent&.has_function?(name)
+      if transient? || !local && @parent&.function_is_modifiable?(name)
         @parent.register_function!(name, function)
       else
         @function_registry.register!(name.to_s, function)

data/lib/keisan/functions/default_registry.rb

@@ -1,4 +1,5 @@
 require_relative "let"
+require_relative "puts"
 
 require_relative "if"
 require_relative "while"
@@ -8,6 +9,7 @@ require_relative "range"
 require_relative "map"
 require_relative "filter"
 require_relative "reduce"
+require_relative "to_h"
 require_relative "rand"
 require_relative "sample"
 require_relative "math_function"
@@ -46,6 +48,7 @@ module Keisan
 
       def self.register_defaults!(registry)
         registry.register!(:let, Let.new, force: true)
+        registry.register!(:puts, Puts.new, force: true)
 
         registry.register!(:if, If.new, force: true)
         registry.register!(:while, While.new, force: true)
@@ -57,6 +60,7 @@ module Keisan
         registry.register!(:select, Filter.new, force: true)
         registry.register!(:reduce, Reduce.new, force: true)
         registry.register!(:inject, Reduce.new, force: true)
+        registry.register!(:to_h, ToH.new, force: true)
 
         register_math!(registry)
         register_array_methods!(registry)

data/lib/keisan/functions/enumerable_function.rb

@@ -0,0 +1,56 @@
+module Keisan
+  module Functions
+    class EnumerableFunction < Function
+      # Filters lists/hashes:
+      # (list, variable, boolean_expression)
+      # (hash, key, value, boolean_expression)
+      def initialize(name)
+        super(name, -3)
+      end
+
+      def value(ast_function, context = nil)
+        evaluate(ast_function, context)
+      end
+
+      def evaluate(ast_function, context = nil)
+        validate_arguments!(ast_function.children.count)
+        context ||= Context.new
+
+        operand, arguments, expression = operand_arguments_expression_for(ast_function, context)
+
+        case operand
+        when AST::List
+          evaluate_list(operand, arguments, expression, context)
+        when AST::Hash
+          evaluate_hash(operand, arguments, expression, context)
+        else
+          raise Exceptions::InvalidFunctionError.new("Unhandled first argument to #{name}: #{operand}")
+        end
+      end
+
+      def simplify(ast_function, context = nil)
+        evaluate(ast_function, context)
+      end
+
+      protected
+
+      def verify_arguments!(arguments)
+        unless arguments.all? {|argument| argument.is_a?(AST::Variable)}
+          raise Exceptions::InvalidFunctionError.new("Middle arguments to #{name} must be variables")
+        end
+      end
+
+      private
+
+      def operand_arguments_expression_for(ast_function, context)
+        operand = ast_function.children[0].simplify(context)
+        arguments = ast_function.children[1...-1]
+        expression = ast_function.children[-1]
+
+        verify_arguments!(arguments)
+
+        [operand, arguments, expression]
+      end
+    end
+  end
+end

data/lib/keisan/functions/filter.rb

@@ -1,61 +1,63 @@
+require "keisan/functions/enumerable_function"
+
 module Keisan
   module Functions
-    class Filter < Function
-      # Filters (list, variable, expression)
-      # e.g. filter([1,2,3,4], x, x % 2 == 0)
-      # should give [2,4]
+    class Filter < EnumerableFunction
+      # Filters lists/hashes:
+      # (list, variable, boolean_expression)
+      # (hash, key, value, boolean_expression)
       def initialize
-        super("filter", 3)
-      end
-
-      def value(ast_function, context = nil)
-        evaluate(ast_function, context)
-      end
-
-      def evaluate(ast_function, context = nil)
-        context ||= Context.new
-        simplify(ast_function, context).evaluate(context)
+        super("filter")
       end
 
-      def simplify(ast_function, context = nil)
-        validate_arguments!(ast_function.children.count)
+      private
 
-        context ||= Context.new
-        list, variable, expression = list_variable_expression_for(ast_function, context)
+      def evaluate_list(list, arguments, expression, context)
+        unless arguments.count == 1
+          raise Exceptions::InvalidFunctionError.new("Filter on list must take 3 arguments")
+        end
+        variable = arguments.first
 
         local = context.spawn_child(transient: false, shadowed: [variable.name])
 
         AST::List.new(
           list.children.select do |element|
             local.register_variable!(variable, element)
-            result = expression.evaluate(local)
+            result = expression.evaluated(local)
 
             case result
             when AST::Boolean
               result.value
             else
-              raise Exceptions::InvalidFunctionError.new("Filter requires expression to be a logical expression")
+              raise Exceptions::InvalidFunctionError.new("Filter requires expression to be a logical expression, received: #{result.to_s}")
             end
           end
         )
       end
 
-      private
+      def evaluate_hash(hash, arguments, expression, context)
+        unless arguments.count == 2
+          raise Exceptions::InvalidFunctionError.new("Filter on hash must take 4 arguments")
+        end
 
-      def list_variable_expression_for(ast_function, context)
-        list = ast_function.children[0].simplify(context)
-        variable = ast_function.children[1]
-        expression = ast_function.children[2]
+        key, value = arguments[0..1]
 
-        unless list.is_a?(AST::List)
-          raise Exceptions::InvalidFunctionError.new("First argument to filter must be a list")
-        end
+        local = context.spawn_child(transient: false, shadowed: [key.name, value.name])
 
-        unless variable.is_a?(AST::Variable)
-          raise Exceptions::InvalidFunctionError.new("Second argument to filter must be a variable")
-        end
+        AST::Hash.new(
+          hash.select do |cur_key, cur_value|
+            local.register_variable!(key, cur_key)
+            local.register_variable!(value, cur_value)
+            result = expression.evaluated(local)
 
-        [list, variable, expression]
+            case result
+            when AST::Boolean
+              result.value
+            else
+              raise Exceptions::InvalidFunctionError.new("Filter requires expression to be a logical expression, received: #{result.to_s}")
+            end
+          end
+        )
       end
     end
   end