keisan 0.6.0 → 0.7.0

data/lib/keisan/functions/map.rb

@@ -1,27 +1,22 @@
+require "keisan/functions/enumerable_function"
+
 module Keisan
   module Functions
-    class Map < Function
-      # Maps (list, variable, expression)
-      # e.g. map([1,2,3], x, 2*x)
-      # should give [2,4,6]
+    class Map < EnumerableFunction
+      # Maps
+      # (list, variable, expression)
+      # (hash, key, value, expression)
       def initialize
-        super("map", 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("map")
       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("Map on list must take 3 arguments")
+        end
+        variable = arguments.first
 
         local = context.spawn_child(transient: false, shadowed: [variable.name])
 
@@ -33,22 +28,21 @@ module Keisan
         )
       end
 
-      private
-
-      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]
-
-        unless list.is_a?(AST::List)
-          raise Exceptions::InvalidFunctionError.new("First argument to map must be a list")
+      def evaluate_hash(hash, arguments, expression, context)
+        unless arguments.count == 2
+          raise Exceptions::InvalidFunctionError.new("Map on hash must take 4 arguments")
         end
+        key, value = arguments[0..1]
 
-        unless variable.is_a?(AST::Variable)
-          raise Exceptions::InvalidFunctionError.new("Second argument to map must be a variable")
-        end
+        local = context.spawn_child(transient: false, shadowed: [key.name, value.name])
 
-        [list, variable, expression]
+        AST::List.new(
+          hash.map do |cur_key, cur_value|
+            local.register_variable!(key, cur_key)
+            local.register_variable!(value, cur_value)
+            expression.simplified(local)
+          end
+        )
       end
     end
   end

data/lib/keisan/functions/puts.rb

@@ -0,0 +1,23 @@
+module Keisan
+  module Functions
+    class Puts < Function
+      def initialize
+        super("puts", 1)
+      end
+
+      def value(ast_function, context = nil)
+        evaluate(ast_function, context)
+      end
+
+      def evaluate(ast_function, context = nil)
+        validate_arguments!(ast_function.children.count)
+        puts ast_function.children.first.evaluate(context).to_s
+        Keisan::AST::Null.new
+      end
+
+      def simplify(ast_function, context = nil)
+        evaluate(ast_function, context)
+      end
+    end
+  end
+end

data/lib/keisan/functions/reduce.rb

@@ -1,27 +1,31 @@
+require "keisan/functions/enumerable_function"
+
 module Keisan
   module Functions
-    class Reduce < Function
+    class Reduce < EnumerableFunction
       # Reduces (list, initial, accumulator, variable, expression)
       # e.g. reduce([1,2,3,4], 0, total, x, total+x)
       # should give 10
       def initialize
-        super("reduce", 5)
+        super("reduce")
       end
 
-      def value(ast_function, context = nil)
-        evaluate(ast_function, context)
-      end
+      protected
 
-      def evaluate(ast_function, context = nil)
-        context ||= Context.new
-        simplify(ast_function, context).evaluate(context)
+      def verify_arguments!(arguments)
+        unless arguments[1..-1].all? {|argument| argument.is_a?(AST::Variable)}
+          raise Exceptions::InvalidFunctionError.new("Middle arguments to #{name} must be variables")
+        end
       end
 
-      def simplify(ast_function, context = nil)
-        validate_arguments!(ast_function.children.count)
+      private
+
+      def evaluate_list(list, arguments, expression, context)
+        unless arguments.count == 3
+          raise Exceptions::InvalidFunctionError.new("Reduce on list must take 3 arguments")
+        end
 
-        context ||= Context.new
-        list, initial, accumulator, variable, expression = list_initial_accumulator_variable_expression_for(ast_function, context)
+        initial, accumulator, variable = arguments[0...3]
 
         local = context.spawn_child(transient: false, shadowed: [accumulator.name, variable.name])
         local.register_variable!(accumulator, initial.simplify(context))
@@ -35,28 +39,24 @@ module Keisan
         local.variable(accumulator.name)
       end
 
-      private
-
-      def list_initial_accumulator_variable_expression_for(ast_function, context)
-        list = ast_function.children[0].simplify(context)
-        initial = ast_function.children[1]
-        accumulator = ast_function.children[2]
-        variable = ast_function.children[3]
-        expression = ast_function.children[4]
-
-        unless list.is_a?(AST::List)
-          raise Exceptions::InvalidFunctionError.new("First argument to reduce must be a list")
+      def evaluate_hash(hash, arguments, expression, context)
+        unless arguments.count == 4
+          raise Exceptions::InvalidFunctionError.new("Reduce on list must take 3 arguments")
         end
 
-        unless accumulator.is_a?(AST::Variable)
-          raise Exceptions::InvalidFunctionError.new("Third argument to reduce is accumulator and must be a variable")
-        end
+        initial, accumulator, key, value = arguments[0...4]
+
+        local = context.spawn_child(transient: false, shadowed: [accumulator.name, key.name, value.name])
+        local.register_variable!(accumulator, initial.simplify(context))
 
-        unless variable.is_a?(AST::Variable)
-          raise Exceptions::InvalidFunctionError.new("Fourth argument to reduce is variable and must be a variable")
+        hash.each do |cur_key, cur_value|
+          local.register_variable!(key, cur_key)
+          local.register_variable!(value, cur_value)
+          result = expression.simplified(local)
+          local.register_variable!(accumulator, result)
         end
 
-        [list, initial, accumulator, variable, expression]
+        local.variable(accumulator.name)
       end
     end
   end

data/lib/keisan/functions/registry.rb

@@ -32,14 +32,14 @@ module Keisan
         false
       end
 
+      def modifiable?(name)
+        !frozen? && has?(name)
+      end
+
       def register!(name, function, force: false)
         raise Exceptions::UnmodifiableError.new("Cannot modify frozen functions registry") if frozen?
         name = name.to_s
 
-        if !force && @use_defaults && default_registry.has_name?(name)
-          raise Exceptions::UnmodifiableError.new("Cannot overwrite default function")
-        end
-
         case function
         when Proc
           self[name] = ProcFunction.new(name, function)

data/lib/keisan/functions/sample.rb

@@ -3,15 +3,17 @@ module Keisan
     class Sample < ProcFunction
       def initialize
         @name = "sample"
-        @arity = 1
+        @arity = ::Range.new(1, 2)
       end
 
-      # Single argument: integer in range [0, max)
-      # Double argument: integer in range [min, max)
+      # Single argument: list to sample element from
+      # Double argument: list and number of elements to sample
       def call(context, *args)
         case args.size
         when 1
           args.first.sample(random: context.random)
+        when 2
+          args[0].sample(args[1], random: context.random)
         else
           raise Exceptions::InvalidFunctionError.new
         end

data/lib/keisan/functions/to_h.rb

@@ -0,0 +1,34 @@
+module Keisan
+  module Functions
+    class ToH < Function
+      def initialize
+        super("to_h", 1)
+      end
+
+      def value(ast_function, context = nil)
+        validate_arguments!(ast_function.children.count)
+        evaluate(ast_function, context).value(context)
+      end
+
+      def evaluate(ast_function, context = nil)
+        validate_arguments!(ast_function.children.count)
+        context ||= Context.new
+
+        child = ast_function.children[0].simplify(context)
+
+        case child
+        when AST::List
+          AST::Hash.new(child.children)
+        when AST::Hash
+          child
+        else
+          raise Exceptions::InvalidFunctionError.new("Cannot call to_h on a #{child.class}")
+        end
+      end
+
+      def simplify(ast_function, context = nil)
+        evaluate(ast_function, context)
+      end
+    end
+  end
+end

data/lib/keisan/interpreter.rb

@@ -0,0 +1,42 @@
+require "keisan/repl"
+
+module Keisan
+  class Interpreter
+    attr_reader :calculator
+
+    def initialize(allow_recursive: false)
+      @calculator = Calculator.new(allow_recursive: allow_recursive)
+    end
+
+    def run(file_name)
+      if file_name.nil?
+        run_from_stdin
+      else
+        run_from_file(file_name)
+      end
+    end
+
+    private
+
+    def run_from_stdin
+      run_on_content STDIN.tty? ? "" : STDIN.read
+    end
+
+    def run_from_file(file_name)
+      run_on_content(
+        File.exists?(file_name) ? File.open(file_name) do |file|
+          file.read
+        end : ""
+      )
+    end
+
+    def run_on_content(content)
+      content = content.strip
+      if content.nil? || content.empty?
+        Repl.new.start
+      else
+        calculator.evaluate(content)
+      end
+    end
+  end
+end

data/lib/keisan/parser.rb

@@ -1,6 +1,6 @@
 module Keisan
   class Parser
-    KEYWORDS = %w(let).freeze
+    KEYWORDS = %w(let puts).freeze
 
     attr_reader :tokens, :components
 
@@ -119,7 +119,9 @@ module Keisan
         elsif token.type == :operator
           add_operator_to_components!(token)
         else
-          raise Exceptions::ParseError.new("Expected an operator, received #{token.string}")
+          # Concatenation is multiplication
+          @components << Parsing::Times.new
+          add_token_to_components!(token)
         end
 
       elsif @components[-1].is_a?(Parsing::Dot)
@@ -196,18 +198,26 @@ module Keisan
       when Tokens::Boolean
         @components << Parsing::Boolean.new(token.value)
       when Tokens::Group
-        case token.group_type
-        when :round
-          @components << Parsing::RoundGroup.new(token.sub_tokens)
-        when :square
-          @components << Parsing::List.new(arguments_from_group(token))
-        when :curly
-          @components << Parsing::CurlyGroup.new(token.sub_tokens)
+        add_group_element_components!(token)
+      else
+        raise Exceptions::ParseError.new("Unhandled operator type #{token.operator_type}")
+      end
+    end
+
+    def add_group_element_components!(token)
+      case token.group_type
+      when :round
+        @components << Parsing::RoundGroup.new(token.sub_tokens)
+      when :square
+        @components << Parsing::List.new(arguments_from_group(token))
+      when :curly
+        if token.sub_tokens.any? {|token| token.is_a?(Tokens::Colon)}
+          @components << Parsing::Hash.new(token.sub_tokens.split {|token| token.is_a?(Tokens::Comma)})
         else
-          raise Exceptions::ParseError.new("Unhandled group type #{token.group_type}")
+          @components << Parsing::CurlyGroup.new(token.sub_tokens)
         end
       else
-        raise Exceptions::ParseError.new("Unhandled operator type #{token.operator_type}")
+        raise Exceptions::ParseError.new("Unhandled group type #{token.group_type}")
       end
     end
 
@@ -215,46 +225,45 @@ module Keisan
       case token.operator_type
       # Assignment
       when :"="
-        @components << Parsing::Assignment.new
-      # Arithmetic
-      when :+
-        @components << Parsing::Plus.new
-      when :-
-        @components << Parsing::Minus.new
-      when :*
-        @components << Parsing::Times.new
-      when :/
-        @components << Parsing::Divide.new
-      when :**
-        @components << Parsing::Exponent.new
-      when :%
-        @components << Parsing::Modulo.new
-      # Bitwise
-      when :"&"
-        @components << Parsing::BitwiseAnd.new
-      when :"|"
-        @components << Parsing::BitwiseOr.new
-      when :"^"
-        @components << Parsing::BitwiseXor.new
-      # Logical
-      when :"=="
-        @components << Parsing::LogicalEqual.new
-      when :"!="
-        @components << Parsing::LogicalNotEqual.new
-      when :"&&"
-        @components << Parsing::LogicalAnd.new
-      when :"||"
-        @components << Parsing::LogicalOr.new
-      when :">"
-        @components << Parsing::LogicalGreaterThan.new
-      when :"<"
-        @components << Parsing::LogicalLessThan.new
-      when :">="
-        @components << Parsing::LogicalGreaterThanOrEqualTo.new
-      when :"<="
-        @components << Parsing::LogicalLessThanOrEqualTo.new
+        add_assignment_to_components!(token)
       else
-        raise Exceptions::ParseError.new("Unhandled operator type #{token.operator_type}")
+        @components << operator_to_component(token.operator_type)
+      end
+    end
+
+    OPERATOR_TO_PARSING_CLASS = {
+      :+    => Parsing::Plus,
+      :-    => Parsing::Minus,
+      :*    => Parsing::Times,
+      :/    => Parsing::Divide,
+      :**   => Parsing::Exponent,
+      :%    => Parsing::Modulo,
+      :"&"  => Parsing::BitwiseAnd,
+      :"|"  => Parsing::BitwiseOr,
+      :"^"  => Parsing::BitwiseXor,
+      :"==" => Parsing::LogicalEqual,
+      :"!=" => Parsing::LogicalNotEqual,
+      :"&&" => Parsing::LogicalAnd,
+      :"||" => Parsing::LogicalOr,
+      :">"  => Parsing::LogicalGreaterThan,
+      :"<"  => Parsing::LogicalLessThan,
+      :">=" => Parsing::LogicalGreaterThanOrEqualTo,
+      :"<=" => Parsing::LogicalLessThanOrEqualTo
+    }.freeze
+
+    def operator_to_component(operator)
+      if klass = OPERATOR_TO_PARSING_CLASS[operator]
+        klass.new
+      else
+        raise Exceptions::ParseError.new("Unhandled operator type #{operator}")
+      end
+    end
+
+    def add_assignment_to_components!(token)
+      if compound_operator = token.compound_operator
+        @components << Parsing::CompoundAssignment.new(compound_operator)
+      else
+        @components << Parsing::Assignment.new
       end
     end
 

data/lib/keisan/parsing/compound_assignment.rb

@@ -0,0 +1,15 @@
+module Keisan
+  module Parsing
+    class CompoundAssignment < Operator
+      attr_reader :compound_operator
+
+      def initialize(compound_operator)
+        @compound_operator = compound_operator
+      end
+
+      def node_class
+        AST::Assignment
+      end
+    end
+  end
+end