skeem 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e19432168939085384bceaf28be0364177ddf91b
-  data.tar.gz: 1256c3c464d7edb6fcf7d3cf6c1d1fd1bd2446ab
+  metadata.gz: 6261d01a57850b9accad9ba2136b59625c37ea58
+  data.tar.gz: 7918e865cadb393e285bfdea1e722970b918549b
 SHA512:
-  metadata.gz: 7817ca715480e6d21c46ba46da12bb6652592f258348968dc3e3c705c717542ddca63b63493758ba2a470e300a5d1263b61762ae21746fc81afede599eae36e7
-  data.tar.gz: 948438de92a59ada9b5589a312df5c71fbd9e884328a6b4c8ad1422578ae0471dbdb170354499a4fa5cd7811809ca38f97785ec183b5c820edce1121b770a656
+  metadata.gz: 1a4efb9e1b96a298448c908e11c1df6a03b810586f7008e10eab9c7336705d3df8e4648155f42737f4fd4453e62ad258af031efc3a884019e42f81babc63b722
+  data.tar.gz: abd048ab5117289e788090947e142805183283b49f05bdd5f16ac491888c8a5f1c6857bc631d51b6db7dc5c9229ccd5b6f65962e7950cdd24bb30c2f761ebb98

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [0.0.9] - 2018-09-15
+Added primitive procedures: 'number?', 'real?', 'integer?'.
+
+### Added
+- Class `PrimitiveBuilder`. Added methods to implement the predicates number?, real?, integer?
+### Changed
+- Class hierarchy `SExprElement`. Prefix `SExpr` in class names changed into 'Skm'
+
 ## [0.0.8] - 2018-09-13
 Added primitive operators: '-', '*', '/' operators.
 

data/lib/skeem/parser.rb

@@ -10,7 +10,7 @@ module Skeem
       # Create a Rley facade object
       @engine = Rley::Engine.new do |cfg| 
         cfg.diagnose = true
-        cfg.repr_builder = SExprBuilder
+        cfg.repr_builder = SkmBuilder
       end
 
       # Step 1. Load Skeem grammar

data/lib/skeem/primitive/primitive_builder.rb

@@ -1,19 +1,26 @@
-require_relative '../primitive_func'
+require_relative '../primitive_procedure'
 
 module Skeem
   module Primitive
     module PrimitiveBuilder
       def add_primitives(aRuntime)
         add_arithmetic(aRuntime)
+        add_number_predicates(aRuntime)
       end
       
       private
       
       def add_arithmetic(aRuntime)
-        def_func(aRuntime, create_plus)
-        def_func(aRuntime, create_minus)
-        def_func(aRuntime, create_multiply)
-        def_func(aRuntime, create_divide)
+        def_procedure(aRuntime, create_plus)
+        def_procedure(aRuntime, create_minus)
+        def_procedure(aRuntime, create_multiply)
+        def_procedure(aRuntime, create_divide)
+      end
+      
+      def add_number_predicates(aRuntime)
+        def_procedure(aRuntime, create_number?)
+        def_procedure(aRuntime, create_real?)
+        def_procedure(aRuntime, create_integer?)
       end
       
       def create_plus()
@@ -22,11 +29,7 @@ module Skeem
           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
+          to_skm(raw_result)
         end
 
         ['+', plus_code]
@@ -38,11 +41,7 @@ module Skeem
           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
+          to_skm(raw_result)
         end
 
         ['-', minus_code]
@@ -54,11 +53,7 @@ module Skeem
           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
+          to_skm(raw_result)
         end
 
         ['*', multiply_code]
@@ -70,24 +65,59 @@ module Skeem
           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
+          to_skm(raw_result)
         end
 
         ['/', divide_code]
+      end
+
+      def create_number?()
+        pred_code = ->(runtime, arg) do
+          arg_evaluated = arg.evaluate(runtime)
+          to_skm(arg_evaluated.number?)
+        end
+
+        ['number?', pred_code]
+      end
+
+      def create_real?()
+        pred_code = ->(runtime, arg) do
+          arg_evaluated = arg.evaluate(runtime)
+          to_skm(arg_evaluated.real?)
+        end
+
+        ['real?', pred_code]
+      end
+
+      def create_integer?()
+        pred_code = ->(runtime, arg) do
+          arg_evaluated = arg.evaluate(runtime)
+          to_skm(arg_evaluated.integer?)
+        end
+
+        ['integer?', pred_code]
       end       
       
-      def def_func(aRuntime, aPair)
-        func = PrimitiveFunc.new(aPair.first, aPair.last)
+      def def_procedure(aRuntime, aPair)
+        func = PrimitiveProcedure.new(aPair.first, aPair.last)
         define(aRuntime, func.identifier, func)
       end
 
       def define(aRuntime, aKey, anEntry)
         aRuntime.define(aKey, anEntry)
       end
+      
+      # Convert Ruby object into its Skeem counterpart
+      def to_skm(native_obj)
+        case native_obj
+          when TrueClass, FalseClass
+            SkmBoolean.create(native_obj)
+          when Float 
+            SkmReal.create(native_obj)
+          when Integer
+            SkmInteger.create(native_obj)     
+        end
+      end
     end # module
   end # module
 end # module

data/lib/skeem/{primitive_func.rb → primitive_procedure.rb}

@@ -1,12 +1,12 @@
 require_relative 's_expr_nodes'
 
 module Skeem
-  class PrimitiveFunc
+  class PrimitiveProcedure
     attr_reader(:identifier)
     attr_reader(:code)
 
     def initialize(anId, aLambda)
-      @identifier = anId.kind_of?(String) ? SExprIdentifier.create(anId) : anId
+      @identifier = anId.kind_of?(String) ? SkmIdentifier.create(anId) : anId
       @code = aLambda
     end
 

data/lib/skeem/s_expr_builder.rb

@@ -9,13 +9,13 @@ module Skeem
   # The Builder pattern creates a complex object
   # (say, a parse tree) from simpler objects (terminal and non-terminal
   # nodes) and using a step by step approach.
-  class SExprBuilder < Rley::ParseRep::ASTBaseBuilder
+  class SkmBuilder < Rley::ParseRep::ASTBaseBuilder
     Terminal2NodeClass = {
-      'BOOLEAN' => SExprBoolean,
-      'IDENTIFIER' => SExprIdentifier,
-      'INTEGER' => SExprInteger,
-      'REAL' => SExprReal,
-      'STRING_LIT' => SExprString
+      'BOOLEAN' => SkmBoolean,
+      'IDENTIFIER' => SkmIdentifier,
+      'INTEGER' => SkmInteger,
+      'REAL' => SkmReal,
+      'STRING_LIT' => SkmString
     }.freeze
 
     # Create a new AST builder instance.

data/lib/skeem/s_expr_nodes.rb

@@ -5,19 +5,31 @@ require 'forwardable'
 
 module Skeem
   # Abstract class. Generalization of any S-expr element.
-  SExprElement = Struct.new(:position) do
+  SkmElement = Struct.new(:position) do
     def initialize(aPosition)
       self.position = aPosition
     end
 
     def evaluate(_runtime)
-      raise NotImplementedError
+      raise NotImplementedError, "Missing implementation of #{self.class.name}"
     end
 
     def done!()
       # Do nothing
     end
 
+    def number?
+      false
+    end
+
+    def real?
+      false
+    end
+
+    def integer?
+      false
+    end
+
     # Abstract method.
     # Part of the 'visitee' role in Visitor design pattern.
     # @param _visitor[ParseTreeVisitor] the visitor
@@ -28,7 +40,7 @@ module Skeem
 
   # Abstract class. Root of class hierarchy needed for Interpreter
   # design pattern
-  class SExprTerminal < SExprElement
+  class SkmTerminal < SkmElement
     attr_reader :token
     attr_reader :value
 
@@ -68,37 +80,46 @@ module Skeem
     end
   end # class
 
-  class SExprBoolean < SExprTerminal
+  class SkmBoolean < SkmTerminal
   end # class
 
-  class SExprNumber < SExprTerminal
+  class SkmNumber < SkmTerminal
+    def number?
+      true
+    end
   end # class
 
-  class SExprReal < SExprTerminal
+  class SkmReal < SkmNumber
+    def real?
+      true
+    end
   end # class
 
-  class SExprInteger < SExprReal
+  class SkmInteger < SkmReal
+    def integer?
+      true
+    end
   end # class
 
-  class SExprString < SExprTerminal
+  class SkmString < SkmTerminal
     # Override
     def init_value(aValue)
       super(aValue.dup)
     end
   end # class
 
-  class SExprIdentifier < SExprTerminal
+  class SkmIdentifier < SkmTerminal
     # Override
     def init_value(aValue)
       super(aValue.dup)
     end
   end # class
 
-  class SExprReserved < SExprIdentifier
+  class SkmReserved < SkmIdentifier
   end # class
 
 
-  class SExprList < SExprElement
+  class SkmList < SkmElement
     attr_accessor(:members)
     extend Forwardable
 
@@ -112,9 +133,19 @@ module Skeem
     def head()
       return members.first
     end
-    
+
     def tail()
-      SExprList.new(members.slice(1..-1))
+      SkmList.new(members.slice(1..-1))
+    end
+
+    def evaluate(aRuntime)
+      result = nil
+
+      members.each do |elem|
+        result = elem.evaluate(aRuntime)
+      end
+
+      result
     end
 
     # Factory method.
@@ -145,21 +176,21 @@ module Skeem
     alias subnodes members
   end # class
 
-  class ProcedureCall < SExprElement
+  class ProcedureCall < SkmElement
     attr_reader :operator
     attr_reader :operands
 
     def initialize(aPosition, anOperator, theOperands)
       super(aPosition)
       @operator = anOperator
-      @operands = SExprList.new(theOperands)
+      @operands = SkmList.new(theOperands)
     end
 
     def evaluate(aRuntime)
       proc_key = operator.evaluate(aRuntime)
       unless aRuntime.include?(proc_key.value)
         err = StandardError
-        key = proc_key.kind_of?(SExprIdentifier) ? proc_key.value : proc_key
+        key = proc_key.kind_of?(SkmIdentifier) ? proc_key.value : proc_key
         err_msg = "Unknown function '#{key}'"
         raise err, err_msg
       end

data/lib/skeem/version.rb

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

data/spec/skeem/interpreter_spec.rb

@@ -31,7 +31,7 @@ module Skeem
       ]
         samples.each do |source, predicted|
           result = subject.run(source)
-          expect(result).to be_kind_of(SExprBoolean)
+          expect(result).to be_kind_of(SkmBoolean)
           expect(result.value).to eq(predicted)
         end
       end
@@ -46,7 +46,7 @@ module Skeem
         ]
         samples.each do |source, predicted|
           result = subject.run(source)
-          expect(result).to be_kind_of(SExprInteger)
+          expect(result).to be_kind_of(SkmInteger)
           expect(result.value).to eq(predicted)
         end
       end
@@ -61,7 +61,7 @@ module Skeem
         ]
         samples.each do |source, predicted|
           result = subject.run(source)
-          expect(result).to be_kind_of(SExprReal)
+          expect(result).to be_kind_of(SkmReal)
           expect(result.value).to eq(predicted)
         end
       end
@@ -72,7 +72,7 @@ module Skeem
       ]
         samples.each do |source, predicted|
           result = subject.run(source)
-          expect(result).to be_kind_of(SExprString)
+          expect(result).to be_kind_of(SkmString)
           expect(result.value).to eq(predicted)
         end
       end
@@ -84,41 +84,81 @@ module Skeem
         ]
         samples.each do |source, predicted|
           result = subject.run(source)
-          expect(result).to be_kind_of(SExprIdentifier)
+          expect(result).to be_kind_of(SkmIdentifier)
           expect(result.value).to eq(predicted)
         end
       end
     end # context
 
-    context 'Built-in primitive functions' do
-      it 'should support the addition of integers' do
+    context 'Built-in primitive procedures' do
+      it 'should implement the addition of integers' do
         result = subject.run('(+ 2 2)')
-        expect(result).to be_kind_of(SExprInteger)
+        expect(result).to be_kind_of(SkmInteger)
         expect(result.value).to eq(4)
       end
 
-      it 'should support the addition of real numbers' do
+      it 'should implement the addition of real numbers' do
         result = subject.run('(+ 2 2.34)')
-        expect(result).to be_kind_of(SExprReal)
+        expect(result).to be_kind_of(SkmReal)
         expect(result.value).to eq(4.34)
       end
-      
-      it 'should support the product of numbers' do
+
+      it 'should implement 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 
+        expect(result).to be_kind_of(SkmInteger)
+        expect(result.value).to eq(24)
+      end
 
-      it 'should support the division of numbers' do
+      it 'should implement 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      
+        expect(result).to be_kind_of(SkmInteger)
+        expect(result.value).to eq(8)
+      end
+
+      it 'should implement the arithmetic expressions' do
         result = subject.run('(+ (* 2 100) (* 1 10))')
-        expect(result).to be_kind_of(SExprInteger)
+        expect(result).to be_kind_of(SkmInteger)
         expect(result.value).to eq(210)
+      end
+      
+      it 'should implement the number? predicate' do
+        checks = [
+          ['(number? 3.1)', true],
+          ['(number? 3)', true],
+          ['(number? "3")', false],
+          ['(number? #t)', false]
+        ]
+        checks.each do |(skeem_expr, expectation)|
+          result = subject.run(skeem_expr)
+          expect(result.value).to eq(expectation)
+        end
+      end
+      
+      it 'should implement the real? predicate' do
+        checks = [
+          ['(real? 3.1)', true],
+          ['(real? 3)', true],
+          ['(real? "3")', false],
+          ['(real? #t)', false]
+        ]
+        checks.each do |(skeem_expr, expectation)|
+          result = subject.run(skeem_expr)
+          expect(result.value).to eq(expectation)
+        end
+      end
+
+      it 'should implement the integer? predicate' do
+        checks = [
+          ['(integer? 3.1)', false],
+          # ['(integer? 3.0)', true], TODO: should pass when exact? will be implemented
+          ['(integer? 3)', true],
+          ['(integer? "3")', false],
+          ['(integer? #t)', false]
+        ]
+        checks.each do |(skeem_expr, expectation)|
+          result = subject.run(skeem_expr)
+          expect(result.value).to eq(expectation)
+        end
       end       
     end # context
   end # describe

data/spec/skeem/parser_spec.rb

@@ -23,7 +23,7 @@ module Skeem
       ]
         samples.each do |source, predicted|
           ptree = subject.parse(source)
-          expect(ptree.root).to be_kind_of(SExprBoolean)
+          expect(ptree.root).to be_kind_of(SkmBoolean)
           expect(ptree.root.value).to eq(predicted)
         end
       end
@@ -38,7 +38,7 @@ module Skeem
       ]
         samples.each do |source, predicted|
           ptree = subject.parse(source)
-          expect(ptree.root).to be_kind_of(SExprInteger)
+          expect(ptree.root).to be_kind_of(SkmInteger)
           expect(ptree.root.value).to eq(predicted)
         end
       end
@@ -53,7 +53,7 @@ module Skeem
       ]
         samples.each do |source, predicted|
           ptree = subject.parse(source)
-          expect(ptree.root).to be_kind_of(SExprReal)
+          expect(ptree.root).to be_kind_of(SkmReal)
           expect(ptree.root.value).to eq(predicted)
         end
       end
@@ -64,7 +64,7 @@ module Skeem
       ]
         samples.each do |source, predicted|
           ptree = subject.parse(source)
-          expect(ptree.root).to be_kind_of(SExprString)
+          expect(ptree.root).to be_kind_of(SkmString)
           expect(ptree.root.value).to eq(predicted)
         end
       end
@@ -75,7 +75,7 @@ module Skeem
       ]
         samples.each do |source, predicted|
           ptree = subject.parse(source)
-          expect(ptree.root).to be_kind_of(SExprIdentifier)
+          expect(ptree.root).to be_kind_of(SkmIdentifier)
           expect(ptree.root.value).to eq(predicted)
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skeem
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-13 00:00:00.000000000 Z
+date: 2018-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -90,7 +90,7 @@ files:
 - lib/skeem/interpreter.rb
 - lib/skeem/parser.rb
 - lib/skeem/primitive/primitive_builder.rb
-- lib/skeem/primitive_func.rb
+- lib/skeem/primitive_procedure.rb
 - lib/skeem/runtime.rb
 - lib/skeem/s_expr_builder.rb
 - lib/skeem/s_expr_nodes.rb