keisan 0.6.0 → 0.7.0

data/lib/keisan/ast.rb

@@ -66,9 +66,20 @@ module KeisanArray
   end
 end
 
+module KeisanHash
+  def to_node
+    Keisan::AST::Hash.new(map {|k,v| [k.to_node, v.to_node]})
+  end
+
+  def value(context = nil)
+    self
+  end
+end
+
 class Numeric; prepend KeisanNumeric; end
 class String; prepend KeisanString; end
 class TrueClass; prepend KeisanTrueClass; end
 class FalseClass; prepend KeisanFalseClass; end
 class NilClass; prepend KeisanNilClass; end
 class Array; prepend KeisanArray; end
+class Hash; prepend KeisanHash; end

data/lib/keisan/ast/assignment.rb

@@ -1,17 +1,26 @@
+require_relative "variable_assignment"
+require_relative "function_assignment"
+require_relative "cell_assignment"
+
 module Keisan
   module AST
     class Assignment < Operator
-      attr_reader :local
+      attr_reader :local, :compound_operator
 
-      def initialize(children = [], parsing_operators = [], local: false)
+      def initialize(children = [], parsing_operators = [], local: false, compound_operator: nil)
         super(children, parsing_operators)
         @local = local
+        @compound_operator = compound_operator
       end
 
       def self.symbol
         :"="
       end
 
+      def symbol
+        :"#{compound_operator}="
+      end
+
       def evaluate(context = nil)
         context ||= Context.new
 
@@ -19,9 +28,9 @@ module Keisan
         rhs = children.last
 
         if is_variable_definition?
-          evaluate_variable(context, lhs, rhs)
+          evaluate_variable_assignment(context, lhs, rhs)
         elsif is_function_definition?
-          evaluate_function(context, lhs, rhs)
+          evaluate_function_assignment(context, lhs, rhs)
         else
           # Try cell assignment
           evaluate_cell_assignment(context, lhs, rhs)
@@ -64,61 +73,17 @@ module Keisan
 
       private
 
-      def evaluate_cell_assignment(context, lhs, rhs)
-        lhs = lhs.evaluate(context)
-        unless lhs.is_a?(Cell)
-          raise Exceptions::InvalidExpression.new("Unhandled left hand side #{lhs} in assignment")
-        end
-
-        rhs = rhs.evaluate(context)
-
-        lhs.node = rhs
-        rhs
+      def evaluate_variable_assignment(context, lhs, rhs)
+        VariableAssignment.new(self, context, lhs, rhs).evaluate
       end
 
-      def evaluate_variable(context, lhs, rhs)
-        rhs = rhs.evaluate(context)
-
-        unless rhs.well_defined?
-          raise Exceptions::InvalidExpression.new("Right hand side of assignment to variable must be well defined")
-        end
-
-        rhs_value = rhs.value(context)
-        context.register_variable!(lhs.name, rhs_value, local: local)
-        # Return the variable assigned value
-        rhs
+      def evaluate_function_assignment(context, lhs, rhs)
+        raise Exceptions::InvalidExpression.new("Cannot do compound assignment on functions") if compound_operator
+        FunctionAssignment.new(context, lhs, rhs, local).evaluate
       end
 
-      def evaluate_function(context, lhs, rhs)
-        unless lhs.children.all? {|arg| arg.is_a?(Variable)}
-          raise Exceptions::InvalidExpression.new("Left hand side function must have variables as arguments")
-        end
-
-        argument_names = lhs.children.map(&:name)
-        function_definition_context = context.spawn_child(shadowed: argument_names, transient: true)
-
-        # Blocks might have local variable/function definitions
-        if !rhs.is_a?(Block)
-          unless rhs.unbound_variables(context) <= Set.new(argument_names)
-            raise Exceptions::InvalidExpression.new("Unbound variables found in function definition")
-          end
-          unless context.allow_recursive || rhs.unbound_functions(context).empty?
-            raise Exceptions::InvalidExpression.new("Unbound function definitions are not allowed by current context")
-          end
-        end
-
-        context.register_function!(
-          lhs.name,
-          Functions::ExpressionFunction.new(
-            lhs.name,
-            argument_names,
-            rhs.evaluate_assignments(function_definition_context),
-            context.transient_definitions
-          ),
-          local: local
-        )
-
-        rhs
+      def evaluate_cell_assignment(context, lhs, rhs)
+        CellAssignment.new(self, context, lhs, rhs).evaluate
       end
     end
   end

data/lib/keisan/ast/boolean.rb

@@ -11,28 +11,32 @@ module Keisan
         bool
       end
 
+      def true?
+        false
+      end
+
       def !
         Boolean.new(!bool)
       end
 
       def and(other)
         other = other.to_node
-        case other
-        when Boolean
-          Boolean.new(bool && other.bool)
-        else
-          super
-        end
+        other.is_a?(Boolean) ? Boolean.new(bool && other.bool) : super
       end
 
       def or(other)
         other = other.to_node
-        case other
-        when Boolean
-          Boolean.new(bool || other.bool)
-        else
-          super
-        end
+        other.is_a?(Boolean) ? Boolean.new(bool || other.bool) : super
+      end
+
+      def equal(other)
+        other = other.to_node
+        other.is_a?(Boolean) ? Boolean.new(value == other.value) : super
+      end
+
+      def not_equal(other)
+        other = other.to_node
+        other.is_a?(Boolean) ? Boolean.new(value != other.value) : super
       end
     end
   end

data/lib/keisan/ast/cell.rb

@@ -24,10 +24,23 @@ module Keisan
         dupped
       end
 
+      def freeze
+        node.freeze
+        super
+      end
+
       def value(context = nil)
         node.value(context)
       end
 
+      def true?
+        node.true?
+      end
+
+      def false?
+        node.false?
+      end
+
       def evaluate(context = nil)
         node.evaluate(context)
       end
@@ -48,6 +61,10 @@ module Keisan
         node.replace(variable, replacement)
       end
 
+      def to_cell
+        self.class.new(node.to_cell)
+      end
+
       def to_s
         node.to_s
       end

data/lib/keisan/ast/cell_assignment.rb

@@ -0,0 +1,70 @@
+module Keisan
+  module AST
+    class CellAssignment
+      attr_reader :assignment, :context, :lhs, :rhs
+
+      def initialize(assignment, context, lhs, rhs)
+        @assignment = assignment
+        @context = context
+        @lhs = lhs
+        @rhs = rhs
+      end
+
+      def evaluate
+        lhs = lhs_evaluate_and_check_modifiable
+
+        unless lhs.is_a?(Cell)
+          raise Exceptions::InvalidExpression.new("Unhandled left hand side #{lhs} in assignment")
+        end
+
+        case assignment.compound_operator
+        when :"||"
+          evaluate_cell_or_assignment(context, lhs, rhs)
+        when :"&&"
+          evaluate_cell_and_assignment(context, lhs, rhs)
+        else
+          evaluate_cell_non_logical_assignment(context, lhs, rhs)
+        end
+      end
+
+      private
+
+      def lhs_evaluate_and_check_modifiable
+        lhs.evaluate(context)
+      rescue RuntimeError => e
+        raise Exceptions::UnmodifiableError.new("Cannot modify frozen variables") if e.message =~ /can't modify frozen/
+        raise
+      end
+
+      def evaluate_cell_or_assignment(context, lhs, rhs)
+        if lhs.false?
+          rhs = rhs.evaluate(context)
+          lhs.node = rhs.is_a?(Cell) ? rhs.node.deep_dup : rhs
+          rhs
+        else
+          lhs
+        end
+      end
+
+      def evaluate_cell_and_assignment(context, lhs, rhs)
+        if lhs.true?
+          rhs = rhs.evaluate(context)
+          lhs.node = rhs.is_a?(Cell) ? rhs.node.deep_dup : rhs
+          rhs
+        else
+          lhs
+        end
+      end
+
+      def evaluate_cell_non_logical_assignment(context, lhs, rhs)
+        rhs = rhs.evaluate(context)
+        if assignment.compound_operator
+          rhs = rhs.send(assignment.compound_operator, lhs.node).evaluate(context)
+        end
+
+        lhs.node = rhs.is_a?(Cell) ? rhs.node.deep_dup : rhs
+        rhs
+      end
+    end
+  end
+end

data/lib/keisan/ast/function_assignment.rb

@@ -0,0 +1,52 @@
+module Keisan
+  module AST
+    class FunctionAssignment
+      attr_reader :context, :lhs, :rhs, :local
+
+      def initialize(context, lhs, rhs, local)
+        @context = context
+        @lhs = lhs
+        @rhs = rhs
+        @local = local
+
+        unless lhs.children.all? {|arg| arg.is_a?(Variable)}
+          raise Exceptions::InvalidExpression.new("Left hand side function must have variables as arguments")
+        end
+      end
+
+      def argument_names
+        @argument_names ||= lhs.children.map(&:name)
+      end
+
+      def expression_function
+        Functions::ExpressionFunction.new(
+          lhs.name,
+          argument_names,
+          rhs.evaluate_assignments(context.spawn_child(shadowed: argument_names, transient: true)),
+          context.transient_definitions
+        )
+      end
+
+      def evaluate
+        # Blocks might have local variable/function definitions, so skip check
+        verify_rhs_of_function_assignment_is_valid! unless rhs.is_a?(Block)
+
+        context.register_function!(lhs.name, expression_function, local: local)
+        rhs
+      end
+
+      private
+
+      def verify_rhs_of_function_assignment_is_valid!
+        # Only variables that can appear are those that are arguments to the function
+        unless rhs.unbound_variables(context) <= Set.new(argument_names)
+          raise Exceptions::InvalidExpression.new("Unbound variables found in function definition")
+        end
+        # Cannot have undefined functions unless allowed by context
+        unless context.allow_recursive || rhs.unbound_functions(context).empty?
+          raise Exceptions::InvalidExpression.new("Unbound function definitions are not allowed by current context")
+        end
+      end
+    end
+  end
+end

data/lib/keisan/ast/hash.rb

@@ -0,0 +1,82 @@
+module Keisan
+  module AST
+    class Hash < Node
+      include Enumerable
+
+      def initialize(key_value_pairs)
+        @hash = ::Hash[key_value_pairs.map(&:to_a).map {|k,v| [k.value, v.to_node]}]
+      end
+
+      def freeze
+        values.each(&:freeze)
+        super
+      end
+
+      def [](key)
+        key = key.to_node
+        return nil unless key.is_a?(AST::ConstantLiteral)
+
+        @hash[key.value] || Cell.new(Null.new).tap do |cell|
+          @hash[key.value] = cell
+        end
+      end
+
+      def evaluate(context = nil)
+        context ||= Context.new
+
+        @hash = ::Hash[
+          @hash.map do |key, val|
+            if val.is_a?(Cell)
+              [key, val]
+            else
+              [key, val.evaluate(context)]
+            end
+          end
+        ]
+
+        self
+      end
+
+      def simplify(context = nil)
+        evaluate(context)
+      end
+
+      def each(&block)
+        @hash.each(&block)
+      end
+
+      def keys
+        @hash.keys
+      end
+
+      def values
+        @hash.values
+      end
+
+      def value(context = nil)
+        context ||= Context.new
+        evaluate(context)
+
+        ::Hash[
+          @hash.map {|key, val|
+            [key, val.value(context)]
+          }
+        ]
+      end
+
+      def to_s
+        "{#{@hash.map {|k,v| "#{k.is_a?(::String) ? "'#{k}'" : k}: #{v}"}.join(', ')}}"
+      end
+
+      def to_cell
+        h = self.class.new([])
+        h.instance_variable_set(:@hash, ::Hash[
+          @hash.map do |key, value|
+            [key, value.to_cell]
+          end
+        ])
+        AST::Cell.new(h)
+      end
+    end
+  end
+end

data/lib/keisan/ast/indexing.rb

@@ -25,24 +25,11 @@ module Keisan
         @children = children.map {|child| child.evaluate(context)}
         @indexes = indexes.map {|index| index.evaluate(context)}
 
-        if list = extract_list
-          list.children[@indexes.first.value(context)]
-        else
-          self
-        end
+        evaluate_list(context) || evaluate_hash(context) || self
       end
 
       def simplify(context = nil)
-        context ||= Context.new
-
-        @indexes = indexes.map {|index| index.simplify(context)}
-        @children = [child.simplify(context)]
-
-        if list = extract_list
-          Cell.new(list.children[@indexes.first.value(context)].simplify(context))
-        else
-          self
-        end
+        evaluate(context)
       end
 
       def replace(variable, replacement)
@@ -52,6 +39,20 @@ module Keisan
 
       private
 
+      def evaluate_list(context)
+        if list = extract_list
+          element = list.children[@indexes.first.value(context)]
+          element.nil? ? AST::Null.new : element
+        end
+      end
+
+      def evaluate_hash(context)
+        if hash = extract_hash
+          element = hash[@indexes.first.value(context)]
+          element.nil? ? AST::Null.new : element
+        end
+      end
+
       def extract_list
         if child.is_a?(List)
           child
@@ -61,6 +62,16 @@ module Keisan
           nil
         end
       end
+
+      def extract_hash
+        if child.is_a?(AST::Hash)
+          child
+        elsif child.is_a?(Cell) && child.node.is_a?(AST::Hash)
+          child.node
+        else
+          nil
+        end
+      end
     end
   end
 end