skeem 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c9907100633d80e63603f094700423139f320600
-  data.tar.gz: 5d4b89ed16eb0c029d98ce02c88eed4cc459404d
+  metadata.gz: e19432168939085384bceaf28be0364177ddf91b
+  data.tar.gz: 1256c3c464d7edb6fcf7d3cf6c1d1fd1bd2446ab
 SHA512:
-  metadata.gz: edd237e0152cbac2cf89bd0724436db40865fddddec40eb4cd3de595909c8a1c09e424f0903903a3cbacf2e3c6fc63fb98770523acda5ffa2099a382f8eccd41
-  data.tar.gz: 3d9605b4577d2701c18cb675b4ea37907b8d7c990c3a9139b6227931b2b68ddf0be8617b6980bf03e640821a958e5d3419b423c95bda128dc6db2837dda4a21e
+  metadata.gz: 7817ca715480e6d21c46ba46da12bb6652592f258348968dc3e3c705c717542ddca63b63493758ba2a470e300a5d1263b61762ae21746fc81afede599eae36e7
+  data.tar.gz: 948438de92a59ada9b5589a312df5c71fbd9e884328a6b4c8ad1422578ae0471dbdb170354499a4fa5cd7811809ca38f97785ec183b5c820edce1121b770a656

data/CHANGELOG.md

@@ -1,6 +1,18 @@
+## [0.0.8] - 2018-09-13
+Added primitive operators: '-', '*', '/' operators.
+
+### Added
+- Class `PrimitiveBuilder`. Added methods to implement the arithmetic operators - (subtraction), * (product), / (division)
+- Class `SExprList`. Class refactoring
+- Class `PrimitiveFunc` Internal representation of primitive functions.
+
+### Changed
+- File `interpreter_spec.rb` Added tests for arithmetic expressions.
+- File `README.md` Changed demo snippet with example of arithmetic expression.
+
 ## [0.0.7] - 2018-09-12
-Proof of concept of a primitive function: '+' operator.  
-Demo works but code needs some polishing and testing.  
+Proof of concept of a primitive function: '+' operator.
+Demo works but code needs some polishing and testing.
 
 ### Added
 - Class `Environment`. Holds a mapping between symbol names and their associated value.
@@ -62,7 +74,7 @@ Parser now generates correct parse trees for expressions consisting of a single
 
 ## [0.0.0] - 2018-08-24
 ### Added
-- Initial Github commit 
+- Initial Github commit
 
 ## Unreleased
 ### Added

data/README.md

@@ -32,11 +32,11 @@ At this stage, the gem consists of a bare-bones interpreter.
 
   schemer = Skeem::Interpreter.new
   scheme_code =<<-SKEEM
-    ; Let's try the addition operator
-    (+ 3 4 5)
+    ; Let's try some arithmetic expression
+    (+ (* 2 100) (* 1 10))
   SKEEM
   result = schemer.run(scheme_code)
-  puts result.value # => 12
+  puts result.value # => 210
 ```
 
 Roadmap:

data/lib/skeem/primitive/primitive_builder.rb

@@ -11,20 +11,75 @@ module Skeem
       
       def add_arithmetic(aRuntime)
         def_func(aRuntime, create_plus)
+        def_func(aRuntime, create_minus)
+        def_func(aRuntime, create_multiply)
+        def_func(aRuntime, create_divide)
       end
       
       def create_plus()
         plus_code = ->(runtime, arglist) do
-          operands = arglist.to_eval_enum(runtime)
-          raw_result = operands.reduce(0) do |interim, elem|
-            interim += elem.value
+          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 }
+          if raw_result.kind_of?(Float) 
+            SExprReal.create(raw_result)
+          else
+            SExprInteger.create(raw_result)
           end
-          SExprInteger.create(raw_result)
         end
 
         ['+', plus_code]
       end
       
+      def create_minus()
+        minus_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 } 
+          if raw_result.kind_of?(Float) 
+            SExprReal.create(raw_result)
+          else
+            SExprInteger.create(raw_result)
+          end
+        end
+
+        ['-', minus_code]
+      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 }          
+          if raw_result.kind_of?(Float) 
+            SExprReal.create(raw_result)
+          else
+            SExprInteger.create(raw_result)
+          end
+        end
+
+        ['*', multiply_code]
+      end
+
+      def create_divide()
+        divide_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 }
+          if raw_result.kind_of?(Float) 
+            SExprReal.create(raw_result)
+          else
+            SExprInteger.create(raw_result)
+          end
+        end
+
+        ['/', divide_code]
+      end       
+      
       def def_func(aRuntime, aPair)
         func = PrimitiveFunc.new(aPair.first, aPair.last)
         define(aRuntime, func.identifier, func)

data/lib/skeem/s_expr_nodes.rb

@@ -104,13 +104,17 @@ module Skeem
 
     def_delegator :@members, :first, :empty?
 
-    def initialize()
+    def initialize(theMembers)
       super(nil)
-      @members = []
+      @members = theMembers.nil? ? [] : theMembers
     end
 
-    def rest()
-      members.slice(1..-1)
+    def head()
+      return members.first
+    end
+    
+    def tail()
+      SExprList.new(members.slice(1..-1))
     end
 
     # Factory method.
@@ -139,8 +143,6 @@ module Skeem
 
     alias children members
     alias subnodes members
-    alias head first
-    alias tail rest
   end # class
 
   class ProcedureCall < SExprElement
@@ -150,16 +152,18 @@ module Skeem
     def initialize(aPosition, anOperator, theOperands)
       super(aPosition)
       @operator = anOperator
-      @operands = SExprList.new
-      @operands.instance_variable_set(:@members, theOperands)
+      @operands = SExprList.new(theOperands)
     end
 
     def evaluate(aRuntime)
-      procedure_key = operator.evaluate(aRuntime)
-      err = StandardError
-      err_msg = "Unknown function #{procedure_key}"
-      raise err, err_msg unless aRuntime.include?(procedure_key.value)
-      procedure = aRuntime.environment.bindings[procedure_key.value]
+      proc_key = operator.evaluate(aRuntime)
+      unless aRuntime.include?(proc_key.value)
+        err = StandardError
+        key = proc_key.kind_of?(SExprIdentifier) ? proc_key.value : proc_key
+        err_msg = "Unknown function '#{key}'"
+        raise err, err_msg
+      end
+      procedure = aRuntime.environment.bindings[proc_key.value]
       result = procedure.call(aRuntime, self)
     end
 

data/lib/skeem/version.rb

@@ -1,3 +1,3 @@
 module Skeem
-  VERSION = '0.0.7'.freeze
+  VERSION = '0.0.8'.freeze
 end

data/spec/skeem/interpreter_spec.rb

@@ -15,7 +15,7 @@ module Skeem
       it 'should have a runtime object' do
         expect(subject.runtime).to be_kind_of(Runtime)
       end
-      
+
       it 'should come with built-in functions' do
         expect(subject.runtime.environment).not_to be_empty
       end
@@ -88,12 +88,38 @@ module Skeem
           expect(result.value).to eq(predicted)
         end
       end
+    end # context
 
-      it 'should support procedure calls' do
-        result = subject.run('(+ 3 4)')
+    context 'Built-in primitive functions' do
+      it 'should support the addition of integers' do
+        result = subject.run('(+ 2 2)')
         expect(result).to be_kind_of(SExprInteger)
-        expect(result.value).to eq(7)
+        expect(result.value).to eq(4)
       end
+
+      it 'should support the addition of real numbers' do
+        result = subject.run('(+ 2 2.34)')
+        expect(result).to be_kind_of(SExprReal)
+        expect(result.value).to eq(4.34)
+      end
+      
+      it 'should support the product of numbers' do
+        result = subject.run('(* 2 3 4)')
+        expect(result).to be_kind_of(SExprInteger)
+        expect(result.value).to eq(24)      
+      end 
+
+      it 'should support the division of numbers' do
+        result = subject.run('(/ 24 3)')
+        expect(result).to be_kind_of(SExprInteger)
+        expect(result.value).to eq(8)      
+      end      
+      
+      it 'should support the arithmetic expressions' do      
+        result = subject.run('(+ (* 2 100) (* 1 10))')
+        expect(result).to be_kind_of(SExprInteger)
+        expect(result.value).to eq(210)
+      end       
     end # context
   end # describe
 end # module

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skeem
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-12 00:00:00.000000000 Z
+date: 2018-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley