skeem 0.0.17 → 0.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0c8a2b41577b541764b4ff1e2702ba30502020a4
-  data.tar.gz: f2844f165479416e313c25452ed7e6d05a8cf722
+  metadata.gz: 40345a7d71935a1329252989a9203c2acd2df799
+  data.tar.gz: d6825f7d3703966a81261551dbcde76e3aa9633f
 SHA512:
-  metadata.gz: a070f9dd299720eb3b5c2b71a3133270183d923a766b9d3a6d10ed62e539875bd59f9fc30aec016756ba82ff359978dec03a8f76a12771710c1f58cdeac64c1d
-  data.tar.gz: 364f3f3d0da779b2cd0e6e083902b9db9fd97368b6254ac80cc700069c53187524fdaf9f1e9724fd3d4dd176cccaa0a0cf786265006fff8b1dd69190641107ba
+  metadata.gz: a8a2f3b40f5869a33962577afa77b33ec6e117bdbcba6764ef485cd9a7941fb15d3fd1b708f1488d8b1f5cacea302d186c2c07165ba3fb42ee8ba755aa99e5f1
+  data.tar.gz: e3ebc87f20fd00380e020e0ca9e24b29e1943d1504bdc4606fda873b05cda6c8af58ed1d497bebc5ee8f0abd40aa2fc2bdf6d9e74250e7c1d4a28acdee831e1d

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [0.0.18] - 2018-10-14
+Reworked procedure argument-passing. 
+
+### Added
+- Classes `SkmArity`, `SkmFormals` implement the core argument counting checks.
+
+### Changed
+- Class `PrimitiveProcedure` vastly reworked to support Scheme's argument passing convention.
+- Class `PrimitiveBuilder` primitive procedures now check the number of arguments.
+- Class `SkmLambda` vastly reworked to support Scheme's argument passing convention. 
+
+### Fixed
+- Method `Tokenizer#skip_whitespaces` Fix: comment lines were ignored in line counting.
+- Method `Tokenizer#_next_token` Fix: mistake in regex for period (dot) recognition.
+
 ## [0.0.17] - 2018-10-06
 - Fix: now support calls of anonymous lambda procedures.
 

data/lib/skeem/grammar.rb

@@ -43,16 +43,16 @@ module Skeem
     rule('operand_plus' => 'operand').as 'last_operand'
     rule 'operator' => 'expression'
     rule 'operand' => 'expression'
-    rule('lambda_expression' => 'LPAREN LAMBDA formals body RPAREN').as 'lambda_expression'
     rule 'def_formals' => 'identifier_star'
-    # rule('def_formals' => 'identifier_star period identifier').as 'dotted_formals'
-    rule('formals' => 'LPAREN identifier_star RPAREN').as 'identifiers_as_formals'
-    rule 'formals' => 'IDENTIFIER'
-    rule 'formals' => 'LPAREN identifier_plus PERIOD IDENTIFIER RPAREN'
+    # rule('def_formals' => 'identifier_star period identifier').as 'OTHER_NAME_formals'    
+    rule('lambda_expression' => 'LPAREN LAMBDA formals body RPAREN').as 'lambda_expression'
+    rule('formals' => 'LPAREN identifier_star RPAREN').as 'fixed_arity_formals'
+    rule('formals' => 'IDENTIFIER').as 'variadic_formals'
+    rule('formals' => 'LPAREN identifier_plus PERIOD IDENTIFIER RPAREN').as 'dotted_formals'
     rule('identifier_star' => 'identifier_star IDENTIFIER').as 'identifier_star'
     rule('identifier_star' => []).as 'no_identifier_yet'
-    rule 'identifier_plus' => 'identifier_plus IDENTIFIER'
-    rule 'identifier_plus' => 'IDENTIFIER'
+    rule('identifier_plus' => 'identifier_plus IDENTIFIER').as 'multiple_identifiers'
+    rule('identifier_plus' => 'IDENTIFIER').as 'last_identifier'
     rule('body' => 'definition_star sequence').as 'body'
     rule 'definition_star' => 'definition_star definition'
     rule 'definition_star' => []

data/lib/skeem/interpreter.rb

@@ -8,13 +8,13 @@ module Skeem
     include Primitive::PrimitiveBuilder
     attr_reader(:parser)
     attr_reader(:runtime)
-    
+
     def initialize()
       @runtime = Runtime.new(Environment.new)
       add_primitives(runtime)
       add_standard(runtime)
     end
-    
+
     def run(source)
       @parser ||= Parser.new
       @ptree = parser.parse(source)
@@ -22,17 +22,21 @@ module Skeem
       return @ptree.root.evaluate(runtime)
     end
     
+    def fetch(anIdentifier)
+      runtime.environment.fetch(anIdentifier)
+    end
+
     private
-    
+
     def add_standard(aRuntime)
       std_pathname = File.dirname(__FILE__) + '/standard/base.skm'
       load_lib(std_pathname)
     end
-    
+
     def load_lib(aPathname)
       lib_source = nil
-      File.open(aPathname, 'r') do |lib| 
-        lib_source = lib.read 
+      File.open(aPathname, 'r') do |lib|
+        lib_source = lib.read
         run(lib_source)
       end
     end

data/lib/skeem/primitive/primitive_builder.rb

@@ -1,4 +1,4 @@
-require_relative '../primitive_procedure'
+require_relative 'primitive_procedure'
 require_relative '../convertible'
 
 module Skeem
@@ -12,214 +12,274 @@ module Skeem
         add_boolean_procedures(aRuntime)
         add_string_procedures(aRuntime)
         add_symbol_procedures(aRuntime)
-        add_output_procedures(aRuntime)
+        add_io_procedures(aRuntime)
         add_special_procedures(aRuntime)
       end
 
       private
+      
+      def nullary
+        SkmArity.new(0, 0) 
+      end
+      
+      def unary
+        SkmArity.new(1, 1)
+      end
+      
+      def binary
+        SkmArity.new(2, 2)
+      end
+      
+      def zero_or_more
+        SkmArity.new(0, '*')
+      end
+      
+      def one_or_more
+        SkmArity.new(1, '*') 
+      end
 
       def add_arithmetic(aRuntime)
-        def_procedure(aRuntime, create_plus)
-        def_procedure(aRuntime, create_minus)
-        def_procedure(aRuntime, create_multiply)
-        def_procedure(aRuntime, create_divide)
-        def_procedure(aRuntime, create_modulo)
+        create_plus(aRuntime)
+        create_minus(aRuntime)
+        create_multiply(aRuntime)
+        create_divide(aRuntime)
+        create_modulo(aRuntime)
       end
 
       def add_comparison(aRuntime)
-        def_procedure(aRuntime, create_equal)
-        def_procedure(aRuntime, create_lt)
-        def_procedure(aRuntime, create_gt)
-        def_procedure(aRuntime, create_lte)
-        def_procedure(aRuntime, create_gte)
+        create_equal(aRuntime)
+        create_lt(aRuntime)
+        create_gt(aRuntime)
+        create_lte(aRuntime)
+        create_gte(aRuntime)
       end
 
       def add_number_predicates(aRuntime)
-        def_procedure(aRuntime, create_number?)
-        def_procedure(aRuntime, create_real?)
-        def_procedure(aRuntime, create_integer?)
+        create_number?(aRuntime)
+        create_real?(aRuntime)
+        create_integer?(aRuntime)
       end
 
       def add_boolean_procedures(aRuntime)
-        def_procedure(aRuntime, create_not)
-        def_procedure(aRuntime, create_boolean?)
+        create_not(aRuntime)
+        create_boolean?(aRuntime)
       end
 
       def add_string_procedures(aRuntime)
-        def_procedure(aRuntime, create_string?)
+        create_string?(aRuntime)
       end
 
       def add_symbol_procedures(aRuntime)
-        def_procedure(aRuntime, create_symbol?)
+        create_symbol?(aRuntime)
       end
 
-      def add_output_procedures(aRuntime)
-        def_procedure(aRuntime, create_newline)
+      def add_io_procedures(aRuntime)(aRuntime)
+        create_newline(aRuntime)
       end
 
       def add_special_procedures(aRuntime)
-         def_procedure(aRuntime, create_debug)
+        create_debug(aRuntime)
       end
 
-      def create_plus()
-        plus_code = ->(runtime, arglist) do
-          first_one = arglist.head.evaluate(runtime)
-          operands = arglist.tail.to_eval_enum(runtime)
-          raw_result = first_one.value
-          operands.each { |elem| raw_result += elem.value }
-          to_skm(raw_result)
+      def create_plus(aRuntime)
+        # arglist should be a Ruby Array
+        primitive = ->(runtime, arglist) do
+          if arglist.empty?
+            to_skm(0)
+          else
+            first_one = arglist.first.evaluate(runtime)
+            raw_result = first_one.value
+            operands = evaluate_tail(arglist, runtime)
+            operands.each { |elem| raw_result += elem.value }
+            to_skm(raw_result)
+          end
         end
-
-        ['+', plus_code]
+        define_primitive_proc(aRuntime, '+', zero_or_more, primitive)
       end
 
-      def create_minus()
-        minus_code = ->(runtime, arglist) do
-          first_one = arglist.head.evaluate(runtime)
+      def create_minus(aRuntime)
+        primitive = ->(runtime, first_operand, arglist) do
+          first_one = first_operand.evaluate(runtime)
           raw_result = first_one.value
-          if arglist.length > 1
-            operands = arglist.tail.to_eval_enum(runtime)
-            operands.each { |elem| raw_result -= elem.value }
-          else
+          if arglist.empty?
             raw_result = -raw_result
+          else
+            operands = evaluate_array(arglist, runtime)
+            operands.each { |elem| raw_result -= elem.value }
           end
           to_skm(raw_result)
         end
 
-        ['-', minus_code]
+        define_primitive_proc(aRuntime, '-', one_or_more, primitive)
       end
 
-      def create_multiply()
-        multiply_code = ->(runtime, arglist) do
-          first_one = arglist.head.evaluate(runtime)
-          operands = arglist.tail.to_eval_enum(runtime)
-          raw_result = first_one.value
-          operands.each { |elem| raw_result *= elem.value }
-          to_skm(raw_result)
+      def create_multiply(aRuntime)
+        primitive = ->(runtime, arglist) do
+          if arglist.empty?
+            to_skm(1)
+          else
+            first_one = arglist.first.evaluate(runtime)
+            raw_result = first_one.value
+            operands = evaluate_tail(arglist, runtime)
+            operands.each { |elem| raw_result *= elem.value }
+            to_skm(raw_result)
+          end
         end
-
-        ['*', multiply_code]
+        define_primitive_proc(aRuntime, '*', zero_or_more, primitive)
       end
 
-      def create_divide()
-        divide_code = ->(runtime, arglist) do
-          first_one = arglist.head.evaluate(runtime)
-          operands = arglist.tail.to_eval_enum(runtime)
+      
+      def create_divide(aRuntime)
+        primitive = ->(runtime, first_operand, arglist) do
+          first_one = first_operand.evaluate(runtime)
           raw_result = first_one.value
-          operands.each { |elem| raw_result /= elem.value }
+          if arglist.empty?
+            raw_result = 1 / raw_result.to_f
+          else
+            operands = evaluate_array(arglist, runtime)
+            operands.each do |elem|
+              if raw_result > elem.value && raw_result.modulo(elem.value).zero?
+                raw_result /= elem.value
+              else
+                raw_result = raw_result.to_f
+                raw_result /= elem.value
+              end
+            end
+          end
           to_skm(raw_result)
         end
-
-        ['/', divide_code]
+        
+        define_primitive_proc(aRuntime, '/', one_or_more, primitive)
       end
 
-
-      def create_modulo()
-        modulo_code = ->(runtime, arglist) do
-          operand_1 = arglist.head.evaluate(runtime)
-          operands = arglist.tail.to_eval_enum(runtime)
-          operand_2 = operands.first.evaluate(runtime)
+      def create_modulo(aRuntime)
+          primitive = ->(runtime, argument1, argument2) do 
+          operand_1 = argument1.evaluate(runtime)
+          operand_2 = argument2.evaluate(runtime)
           raw_result = operand_1.value.modulo(operand_2.value)
           to_skm(raw_result)
         end
 
-        ['floor-remainder', modulo_code, 'modulo', modulo_code]
+        define_primitive_proc(aRuntime, 'floor-remainder', binary, primitive) 
       end
 
-
-      def create_equal
-        equal_code = ->(runtime, arglist) do
-          first_one = arglist.head.evaluate(runtime)
-          operands = arglist.tail.to_eval_enum(runtime)
-          first_value = first_one.value
-          all_equal = operands.all? { |elem| first_value == elem.value }
-          to_skm(all_equal)
+      def create_equal(aRuntime)
+        primitive = ->(runtime, first_operand, arglist) do
+          first_one = first_operand.evaluate(runtime)
+          if arglist.empty?
+            to_skm(true)
+          else
+            operands = evaluate_array(arglist, runtime)         
+            first_value = first_one.value
+            all_equal = operands.all? { |elem| first_value == elem.value }
+            to_skm(all_equal)
+          end
         end
 
-        ['=', equal_code]
+        define_primitive_proc(aRuntime, '=', one_or_more, primitive)
       end
 
-      def create_lt
-        lt_code = ->(runtime, arglist) do
-          operands = arglist.to_eval_enum(runtime)
-          result = true
-          operands.each_cons(2) do |(elem1, elem2)|
-            result &&= elem1.value < elem2.value
+      def create_lt(aRuntime)
+        primitive = ->(runtime, first_operand, arglist) do
+          if arglist.empty?
+            to_skm(false)
+          else        
+            operands = [first_operand.evaluate(runtime)]
+            operands.concat(evaluate_array(arglist, runtime))
+            result = true
+            operands.each_cons(2) do |(elem1, elem2)|
+              result &&= elem1.value < elem2.value
+            end
+            to_skm(result)
           end
-          to_skm(result)
         end
 
-        ['<', lt_code]
+        define_primitive_proc(aRuntime, '<', one_or_more, primitive)
       end
 
-      def create_gt
-        gt_code = ->(runtime, arglist) do
-          operands = arglist.to_eval_enum(runtime)
-          result = true
-          operands.each_cons(2) do |(elem1, elem2)|
-            result &&= elem1.value > elem2.value
+      def create_gt(aRuntime)
+        primitive = ->(runtime, first_operand, arglist) do
+          if arglist.empty?
+            to_skm(false)
+          else        
+            operands = [first_operand.evaluate(runtime)]
+            operands.concat(evaluate_array(arglist, runtime))
+            result = true
+            operands.each_cons(2) do |(elem1, elem2)|
+              result &&= elem1.value > elem2.value
+            end
+            to_skm(result)
           end
-          to_skm(result)
         end
 
-        ['>', gt_code]
+        define_primitive_proc(aRuntime, '>', one_or_more, primitive)
       end
 
-      def create_lte
-        lte_code = ->(runtime, arglist) do
-          operands = arglist.to_eval_enum(runtime)
-          result = true
-          operands.each_cons(2) do |(elem1, elem2)|
-            result &&= elem1.value <= elem2.value
+      def create_lte(aRuntime)
+        primitive = ->(runtime, first_operand, arglist) do
+          if arglist.empty?
+            to_skm(true)
+          else        
+            operands = [first_operand.evaluate(runtime)]
+            operands.concat(evaluate_array(arglist, runtime))
+            result = true
+            operands.each_cons(2) do |(elem1, elem2)|
+              result &&= elem1.value <= elem2.value
+            end
+            to_skm(result)
           end
-          to_skm(result)
         end
 
-        ['<=', lte_code]
+        define_primitive_proc(aRuntime, '<=', one_or_more, primitive)
       end
 
-      def create_gte
-        gte_code = ->(runtime, arglist) do
-          operands = arglist.to_eval_enum(runtime)
-          result = true
-          operands.each_cons(2) do |(elem1, elem2)|
-            result &&= elem1.value >= elem2.value
+      def create_gte(aRuntime)
+        primitive = ->(runtime, first_operand, arglist) do
+          if arglist.empty?
+            to_skm(true)
+          else        
+            operands = [first_operand.evaluate(runtime)]
+            operands.concat(evaluate_array(arglist, runtime))
+            result = true
+            operands.each_cons(2) do |(elem1, elem2)|
+              result &&= elem1.value >= elem2.value
+            end
+            to_skm(result)
           end
-          to_skm(result)
         end
 
-        ['>=', gte_code]
+        define_primitive_proc(aRuntime, '>=', one_or_more, primitive)
       end
 
-      def create_number?()
-        pred_code = ->(runtime, arg) do
-          arg_evaluated = arg.evaluate(runtime)
+      def create_number?(aRuntime)
+         primitive = ->(runtime, object) do
+          arg_evaluated = object.evaluate(runtime)
           to_skm(arg_evaluated.number?)
         end
 
-        ['number?', pred_code]
+        define_primitive_proc(aRuntime, 'number?', unary, primitive)
       end
 
-      def create_real?()
-        pred_code = ->(runtime, arg) do
+      def create_real?(aRuntime)
+        primitive = ->(runtime, arg) do
           arg_evaluated = arg.evaluate(runtime)
           to_skm(arg_evaluated.real?)
         end
 
-        ['real?', pred_code]
+        define_primitive_proc(aRuntime, 'real?', unary, primitive)
       end
 
-      def create_integer?()
-        pred_code = ->(runtime, arg) do
+      def create_integer?(aRuntime)
+        primitive = ->(runtime, arg) do
           arg_evaluated = arg.evaluate(runtime)
           to_skm(arg_evaluated.integer?)
         end
 
-        ['integer?', pred_code]
+        define_primitive_proc(aRuntime, 'integer?', unary, primitive)
       end
 
-      def create_not()
-        logical = ->(runtime, arg) do
+      def create_not(aRuntime)
+        primitive = ->(runtime, arg) do
           arg_evaluated = arg.evaluate(runtime)
           if arg_evaluated.boolean? && arg_evaluated.value == false
             to_skm(true)
@@ -227,51 +287,52 @@ module Skeem
             to_skm(false)
           end
         end
-        ['not', logical]
+        
+        define_primitive_proc(aRuntime, 'not', unary, primitive)
       end
 
-      def create_boolean?()
-        pred_code = ->(runtime, arg) do
+      def create_boolean?(aRuntime)
+        primitive = ->(runtime, arg) do
           arg_evaluated = arg.evaluate(runtime)
           to_skm(arg_evaluated.boolean?)
         end
 
-        ['boolean?', pred_code]
+        define_primitive_proc(aRuntime, 'boolean?', unary, primitive)
       end
 
-      def create_string?()
-        pred_code = ->(runtime, arg) do
+      def create_string?(aRuntime)
+        primitive = ->(runtime, arg) do
           arg_evaluated = arg.evaluate(runtime)
           to_skm(arg_evaluated.string?)
         end
 
-        ['string?', pred_code]
+        define_primitive_proc(aRuntime, 'string?', unary, primitive)
       end
 
-      def create_symbol?
-        pred_code = ->(runtime, arg) do
+      def create_symbol?(aRuntime)
+        primitive = ->(runtime, arg) do
           arg_evaluated = arg.evaluate(runtime)
           to_skm(arg_evaluated.symbol?)
         end
 
-        ['symbol?', pred_code]
+        define_primitive_proc(aRuntime, 'symbol?', unary, primitive)
       end
 
-      def create_newline
-        nl_code = ->(runtime, arg) do
+      def create_newline(aRuntime)
+        primitive = ->(runtime) do
           # @TODO: make output stream configurable
           print "\n"
         end
 
-        ['newline', nl_code]
+        define_primitive_proc(aRuntime, 'newline', nullary, primitive)
       end
 
-      def create_debug
-        debug_code = ->(runtime, arg) do
+      def create_debug(aRuntime)
+        primitive = ->(runtime) do
           require 'debug'
         end
 
-        ['debug', debug_code]
+        define_primitive_proc(aRuntime, 'debug', nullary, primitive)
       end
 
 
@@ -281,10 +342,23 @@ module Skeem
           define(aRuntime, func.identifier, func)
         end
       end
+      
+      def define_primitive_proc(aRuntime, anIdentifier, anArity, aRubyLambda)
+        primitive = PrimitiveProcedure.new(anIdentifier, anArity, aRubyLambda)
+        define(aRuntime, primitive.identifier, primitive)
+      end
 
       def define(aRuntime, aKey, anEntry)
         aRuntime.define(aKey, anEntry)
       end
+      
+      def evaluate_array(anArray, aRuntime)
+        anArray.map { |elem| elem.evaluate(aRuntime) }
+      end      
+      
+      def evaluate_tail(anArray, aRuntime)
+        evaluate_array(anArray.drop(1), aRuntime)
+      end      
     end # module
   end # module
 end # module