skeem 0.2.09 → 0.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a85fc0a12d54eedba56c28e18d728d00ff35044c029e1a256d4381a98c6310a8
-  data.tar.gz: 934cc810162a891fdddffdbfb16466ed7d7c71da8d7c5cb77670c010b5bf83fe
+  metadata.gz: 482a0c8f936db1cc3099e133dda1d42d685d5e3c7fe244bf98f0062ad1470bc1
+  data.tar.gz: e950b89cf3a4bc7971a5263e96f7a8dbb670d926b03601d2c4116ccc03b613ec
 SHA512:
-  metadata.gz: 6dcdf9eb8d85abdcd4d2f416b9e9fa6ed1d9b399b92c9921ff59fb8dc6d6f047e5064fd7ccffde3ae000771079a0a7d9f64643e0585ba0c39b0566b345a5b994
-  data.tar.gz: 60347248374f6723c91edc3699b1306056b02bfc7a91a52e9dcfa15690f72294bf89cfd1ef8551218a6e67751bdde59f972c6ec1ea0e42733436d7caa5b26bac
+  metadata.gz: a8a6cde2cd049ccdf7ac4256b2313a462990f355790e6a23ab78febaa9f2377a39914f169c213e5ec1b2342e6bc611eeddae6f8f806ac3ecff713a356765403c
+  data.tar.gz: 6b9ea76b548deb643631515a755c431a30c915ad1db1dee609ceec1c03e17380d99f0fe33d1ab80a4eda4eec9de3a4acc55e03d6f8d4ebac800f650ad9695554

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+## [0.2.10] - 2019-06-15
+- Skeem now supports rational numbers (fractions)
+- Added procedures: `max`, `min`, `floor/`, `floor-quotient`, `floor-remainder`, `truncate/`, `truncate-quotient`,
+  `truncate-remainder`, `quotient`, `remainder`, `modulo`
+
+### Added
+- `DatumDSL#rational` conversion method
+
+### Changed
+- `DatumDSL#to_datum(aLiteral): added conversion of literal rational into rational value.
+- File `grammar.rb` Added new terminal RATIONAL and rule deriving number from rational
+- File `primitive_builder.rb` Implemented primitive procedures floor/ and truncate/
+- Class `SkmInteger` now inherits from `SkmRational` class
+- File `base.skm` added implementation of  `floor-quotient`, `floor-remainder`, `truncate-quotient`, 
+  `truncate-remainder`, `quotient`, `remainder`, `modulo`
+ - Class Tokenizer updated to recognize rational numbers.
+ - Test suite file `base_tests.scm` expanded.
+
+### Fixed
+- File `primitive_builder.rb` Fixed and extended implementation of `/`procedure
+
 ## [0.2.09] - 2019-06-10
 - New procedures: `complex?`, `exact-integer?`
 - Support for `#| ... |#` block comments (including nesting)

data/README.md

@@ -174,6 +174,7 @@ Here are a few pointers for the Scheme programming language:
 - Booleans: `#t`, `#true`, `#f`, `#false`
 - Of the number hierarchy:  
   `real` (e.g. 2.718, 6.671e-11),  
+  `rational` (e.g. 22/7, 1/137, -13/41)
   `integer` (42, -3)
 - Lists (quoted) : '(1 two "three")
 - Strings: `"Hello, world."`
@@ -250,9 +251,10 @@ This section lists the implemented standard procedures
 * `boolean?`, `and`, `or`,  `not`
 
 #### Numerical operations
-* Number-level: `number?`, `complex?`, `real?`, `integer?`, `zero?`, `exact?`, `inexact?`, `exact-integer?` , `+`, `-`, `*`, `/`,
+* Number-level: `number?`, `complex?`, `real?`, `rational?`, `integer?`, `zero?`, `exact?`, `inexact?`, `exact-integer?` , `+`, `-`, `*`, `/`,
 `=`, `square`, `number->string`
-* Real-level: `positive?`, `negative?`, `<`, `>`, `<=`, `>=`, `abs`, `floor-remainder`
+* Real-level: `positive?`, `negative?`, `<`, `>`, `<=`, `>=`, `abs`, `max`, `min`,  `floor/`, `floor-quotient`, `floor-remainder`, `truncate/`, `truncate-quotient`,
+  `truncate-remainder`, `quotient`, `remainder`, `modulo`
 * Integer-level: `even?`, `odd?`
 
 #### List procedures

data/lib/skeem/datum_dsl.rb

@@ -33,6 +33,19 @@ module Skeem
           raise StandardError, aLiteral.inspect
       end
     end
+    
+    def rational(aLiteral)
+      return aLiteral if aLiteral.kind_of?(SkmRational)
+
+      result = case aLiteral
+        when Rational
+          SkmRational.create(aLiteral)
+        when /^[+-]?\d+\/\d+$/
+          SkmRational.create(Rational(aLiteral))
+        else
+          raise StandardError, aLiteral.inspect
+      end
+    end    
 
     def real(aLiteral)
       return aLiteral if aLiteral.kind_of?(SkmReal)
@@ -112,6 +125,8 @@ module Skeem
           aLiteral.map { |elem| to_datum(elem) }
         when Integer
           SkmInteger.create(aLiteral)
+        when Rational
+          SkmRational.create(aLiteral)
         when Float
           SkmReal.create(aLiteral)
         when TrueClass, FalseClass
@@ -133,6 +148,8 @@ module Skeem
         boolean(aLiteral)
       elsif aLiteral =~ /^#f(?:alse)?|false$/
         boolean(aLiteral)
+      elsif aLiteral =~ /^[+-]?\d+\/\d+$/
+        rational(aLiteral)
       elsif aLiteral =~ /^[+-]?\d+$/
         integer(aLiteral)
       elsif aLiteral =~ /^[+-]?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?$/

data/lib/skeem/grammar.rb

@@ -15,8 +15,8 @@ module Skeem
     add_terminals('VECTOR_BEGIN')
 
     # Literal values...
-    add_terminals('BOOLEAN', 'INTEGER', 'REAL')
-    add_terminals('STRING_LIT', 'IDENTIFIER')
+    add_terminals('BOOLEAN', 'INTEGER', 'RATIONAL')
+    add_terminals('REAL', 'STRING_LIT', 'IDENTIFIER')
 
     # Keywords...
     add_terminals('BEGIN', 'COND', 'DEFINE', 'ELSE')
@@ -93,6 +93,7 @@ module Skeem
     rule 'alternate' => 'expression'
     rule 'alternate' => []
     rule 'number' => 'INTEGER'
+    rule 'number' => 'RATIONAL'
     rule 'number' => 'REAL'
     rule('assignment' => 'LPAREN SET! IDENTIFIER expression RPAREN').as 'assignment'
     rule('derived_expression' => 'LPAREN COND cond_clause_plus RPAREN').as 'cond_form'

data/lib/skeem/primitive/primitive_builder.rb

@@ -51,7 +51,8 @@ module Skeem
         create_minus(aRuntime)
         create_multiply(aRuntime)
         create_divide(aRuntime)
-        create_modulo(aRuntime)
+        create_floor_slash(aRuntime)
+        create_truncate_slash(aRuntime)
       end
 
       def add_comparison(aRuntime)
@@ -63,12 +64,15 @@ module Skeem
         create_gt(aRuntime)
         create_lte(aRuntime)
         create_gte(aRuntime)
+        create_max(aRuntime)
+        create_min(aRuntime)
       end
 
       def add_number_procedures(aRuntime)
         create_object_predicate(aRuntime, 'number?')
         create_object_predicate(aRuntime, 'complex?')
         create_object_predicate(aRuntime, 'real?')
+        create_object_predicate(aRuntime, 'rational?')
         create_object_predicate(aRuntime, 'integer?')
         create_object_predicate(aRuntime, 'exact?')
         create_number2string(aRuntime)
@@ -178,19 +182,47 @@ module Skeem
         define_primitive_proc(aRuntime, '*', zero_or_more, primitive)
       end
 
+      def reciprocal(aLiteral)
+
+        case aLiteral
+          when Integer
+            result = Rational(1, aLiteral)
+          when Rational
+            result = Rational(aLiteral.denominator, aLiteral.numerator)
+          else
+            result = 1 / aLiteral.to_f
+        end
+
+        result
+      end
 
       def create_divide(aRuntime)
         primitive = ->(_runtime, first_operand, arglist) do
           raw_result = first_operand.value
           if arglist.empty?
-            raw_result = 1 / raw_result.to_f
+            raw_result = reciprocal(raw_result)
           else
+            # Ugly: Ruby version dependency: Rubies older than 2.4 have class Fixnum instead of Integer
+            int_class = (RUBY_VERSION[0..2] < "2.4") ? Fixnum : Integer
+
             arglist.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
+              elem_value = elem.value
+              case [raw_result.class, elem_value.class]
+                when [int_class, int_class]
+                  if raw_result.modulo(elem_value).zero?
+                    raw_result = raw_result / elem_value
+                  else
+                    raw_result = Rational(raw_result, elem_value)
+                  end
+
+                when [int_class, Rational]
+                  raw_result = raw_result * reciprocal(elem_value)
+
+                when [Rational, Rational]
+                  raw_result = raw_result * reciprocal(elem_value)
+                else
+                  raw_result = raw_result.to_f
+                  raw_result /= elem_value
               end
             end
           end
@@ -200,13 +232,24 @@ module Skeem
         define_primitive_proc(aRuntime, '/', one_or_more, primitive)
       end
 
-      def create_modulo(aRuntime)
+      def create_floor_slash(aRuntime)
         primitive = ->(_runtime, operand_1, operand_2) do
-          raw_result = operand_1.value.modulo(operand_2.value)
-          to_datum(raw_result)
+          (quotient, modulus) = operand_1.value.divmod(operand_2.value)
+          SkmPair.new(to_datum(quotient), to_datum(modulus)) # improper list!
+        end
+
+        define_primitive_proc(aRuntime, 'floor/', binary, primitive)
+      end
+
+      def create_truncate_slash(aRuntime)
+        primitive = ->(_runtime, operand_1, operand_2) do
+          modulo_ = operand_1.value / operand_2.value
+          modulo_ += 1 if modulo_ < 0
+          remainder_ = operand_1.value.remainder(operand_2.value)
+          SkmPair.new(to_datum(modulo_), to_datum(remainder_)) # improper list!
         end
 
-        define_primitive_proc(aRuntime, 'floor-remainder', binary, primitive)
+        define_primitive_proc(aRuntime, 'truncate/', binary, primitive)
       end
 
       def core_eqv?(eval_arg1, eval_arg2)
@@ -309,7 +352,7 @@ module Skeem
 
         define_primitive_proc(aRuntime, '>=', one_or_more, primitive)
       end
-      
+
       def primitive_comparison(operator, _runtime, first_operand, arglist)
         operands = [first_operand].concat(arglist)
         result = true
@@ -317,7 +360,43 @@ module Skeem
           result &&= elem1.value.send(operator, elem2.value)
         end
 
-        boolean(result)      
+        boolean(result)
+      end
+
+      def create_max(aRuntime)
+        primitive = ->(_runtime, first_operand, arglist) do
+          if arglist.empty?
+            result = first_operand
+          else
+            arr = arglist.to_a
+            arr.unshift(first_operand)
+            result = arr.max do |a, b|
+              a.value <=> b.value if a.real? && b.real?
+            end
+          end
+
+          result
+        end
+
+        define_primitive_proc(aRuntime, 'max', one_or_more, primitive)
+      end
+
+      def create_min(aRuntime)
+        primitive = ->(_runtime, first_operand, arglist) do
+          if arglist.empty?
+            result = first_operand
+          else
+            arr = arglist.to_a
+            arr.unshift(first_operand)
+            result = arr.min do |a, b|
+              a.value <=> b.value if a.real? && b.real?
+            end
+          end
+
+          result
+        end
+
+        define_primitive_proc(aRuntime, 'min', one_or_more, primitive)
       end
 
       def create_number2string(aRuntime)

data/lib/skeem/s_expr_builder.rb

@@ -16,6 +16,7 @@ module Skeem
       'BOOLEAN' => SkmBoolean,
       'IDENTIFIER' => SkmIdentifier,
       'INTEGER' => SkmInteger,
+      'RATIONAL' => SkmRational,
       'REAL' => SkmReal,
       'STRING_LIT' => SkmString
     }.freeze

data/lib/skeem/skm_element.rb

@@ -12,10 +12,18 @@ module Skeem
     def number?
       false
     end
+    
+    def complex?
+      false
+    end    
 
     def real?
       false
     end
+    
+    def rational?
+      false
+    end
 
     def integer?
       false

data/lib/skeem/skm_simple_datum.rb

@@ -132,15 +132,21 @@ module Skeem
       false
     end
   end # class
-
-  class SkmInteger < SkmReal
-    def integer?
+  
+  class SkmRational < SkmReal
+    def rational?
       true
     end
 
     def exact?
       true
     end
+  end # class  
+
+  class SkmInteger < SkmRational
+    def integer?
+      true
+    end
   end # class
 
   class SkmString < SkmSimpleDatum

data/lib/skeem/standard/base.skm

@@ -36,8 +36,34 @@
 (define inexact?
   (lambda (z) 
     (not (exact? z))))
-
-; For backwards compatibility
+    
+(define floor-quotient
+  (lambda (n1 n2)
+    (car (floor/ n1 n2))))
+
+(define floor-remainder
+  (lambda (n1 n2)
+    (cdr (floor/ n1 n2))))
+    
+(define truncate-quotient
+  (lambda (n1 n2)
+    (car (truncate/ n1 n2))))
+
+(define truncate-remainder
+  (lambda (n1 n2)
+    (cdr (truncate/ n1 n2))))
+
+; For R5RS compatibility
+(define quotient
+  (lambda (x y)
+    (truncate-quotient x y)))
+    
+; For R5RS compatibility
+(define remainder
+  (lambda (x y)
+    (truncate-remainder x y)))
+    
+; For R5RS compatibility
 (define modulo
   (lambda (x y)
     (floor-remainder x y)))

data/lib/skeem/tokenizer.rb

@@ -93,6 +93,8 @@ module Skeem
         token = build_token(@@lexeme2name[lexeme], lexeme)
       elsif (lexeme = scanner.scan(/#(?:(?:true)|(?:false)|(?:u8)|[\\\(tfeiodx]|(?:\d+[=#]))/))
         token = cardinal_token(lexeme)
+      elsif (lexeme = scanner.scan(/[+-]?[0-9]+\/[0-9]+(?=\s|[|()";]|$)/))
+        token = build_token('RATIONAL', lexeme) # Decimal radix        
       elsif (lexeme = scanner.scan(/[+-]?[0-9]+(?:.0+)?(?=\s|[|()";]|$)/))
         token = build_token('INTEGER', lexeme) # Decimal radix
       elsif (lexeme = scanner.scan(/[+-]?[0-9]+(?:\.[0-9]*)?(?:(?:e|E)[+-]?[0-9]+)?/))
@@ -152,10 +154,10 @@ other literal data (section 2.4).
 
     def build_token(aSymbolName, aLexeme, aFormat = :default)
       begin
-        value = convert_to(aLexeme, aSymbolName, aFormat)
+        (value, symb) = convert_to(aLexeme, aSymbolName, aFormat)
         col = scanner.pos - aLexeme.size - @line_start + 1
         pos = Rley::Lexical::Position.new(@lineno, col)
-        token = Rley::Lexical::Token.new(value, aSymbolName, pos)
+        token = Rley::Lexical::Token.new(value, symb, pos)
       rescue StandardError => exc
         puts "Failing with '#{aSymbolName}' and '#{aLexeme}'"
         raise exc
@@ -165,11 +167,15 @@ other literal data (section 2.4).
     end
 
     def convert_to(aLexeme, aSymbolName, aFormat)
+      symb = aSymbolName
       case aSymbolName
       when 'BOOLEAN'
         value = to_boolean(aLexeme, aFormat)
       when 'INTEGER'
         value = to_integer(aLexeme, aFormat)
+      when 'RATIONAL'
+        value = to_rational(aLexeme, aFormat)
+        symb = 'INTEGER' if value.kind_of?(Integer)
       when 'REAL'
         value = to_real(aLexeme, aFormat)
       when 'STRING_LIT'
@@ -180,7 +186,7 @@ other literal data (section 2.4).
         value = aLexeme
       end
 
-      return value
+      return [value, symb]
     end
 
     def to_boolean(aLexeme, aFormat)
@@ -196,6 +202,16 @@ other literal data (section 2.4).
       return value
     end
 
+    def to_rational(aLexeme, aFormat)
+      case aFormat
+      when :default
+        value = Rational(aLexeme)
+        value = value.numerator if value.denominator == 1
+      end
+
+      return value
+    end
+    
     def to_real(aLexeme, aFormat)
       case aFormat
       when :default

data/lib/skeem/version.rb

@@ -1,3 +1,3 @@
 module Skeem
-  VERSION = '0.2.09'.freeze
+  VERSION = '0.2.10'.freeze
 end

data/spec/skeem/datum_dsl_spec.rb

@@ -35,6 +35,15 @@ module Skeem
         ['+456', 456]
       ]
     end
+    
+    let(:rational_tests) do
+      [
+        [-Rational(2,3), -Rational(2, 3)],
+        [Rational(22, 7), Rational(22, 7)],
+        ['-2/3', -Rational(2, 3)],
+        ['+22/7', Rational(22, 7)]
+      ]
+    end    
 
     let(:real_tests) do
       [
@@ -83,6 +92,12 @@ module Skeem
           expect(subject.integer(literal)).to eq(predicted)
         end
       end
+      
+      it 'should convert rational literals' do
+        rational_tests.each do |(literal, predicted)|
+          expect(subject.rational(literal)).to eq(predicted)
+        end
+      end      
 
       it 'should convert real number literals' do
         real_tests.each do |(literal, predicted)|
@@ -163,6 +178,12 @@ module Skeem
           expect(subject.to_datum(literal)).to eq(predicted)
         end
       end
+      
+      it 'should recognize & convert rational literals' do
+        rational_tests.each do |(literal, predicted)|
+          expect(subject.to_datum(literal)).to eq(predicted)
+        end
+      end      
 
       it 'should recognize & convert real number literals' do
         real_tests.each do |(literal, predicted)|

data/spec/skeem/interpreter_spec.rb

@@ -825,6 +825,82 @@ SKEEM
           expect(result).to eq(expectation)
         end
       end
+
+      it 'should implement the floor-quotient procedure' do
+        checks = [
+          ['(floor-quotient 5 2)', 2],
+          ['(floor-quotient -5 2)', -3],
+          ['(floor-quotient 5 -2)', -3],
+          ['(floor-quotient -5 -2)', 2]
+        ]
+        checks.each do |(skeem_expr, expectation)|
+          result = subject.run(skeem_expr)
+          expect(result).to eq(expectation)
+        end
+      end
+      
+      it 'should implement the floor-remainder (modulo) procedure' do
+        checks = [
+          ['(floor-remainder 16 4)', 0],
+          ['(floor-remainder 5 2)', 1],
+          ['(floor-remainder -45.0 7)', 4.0],
+          ['(floor-remainder 10.0 -3.0)', -2.0],
+          ['(floor-remainder -17 -9)', -8],
+          ['(modulo 16 4)', 0],
+          ['(modulo 5 2)', 1],
+          ['(modulo -45.0 7)', 4.0],
+          ['(modulo 10.0 -3.0)', -2.0],
+          ['(modulo -17 -9)', -8]          
+        ]
+        checks.each do |(skeem_expr, expectation)|
+          result = subject.run(skeem_expr)
+          expect(result).to eq(expectation)
+        end
+      end
+      
+        it 'should implement the truncate-quotient procedure' do
+          checks = [
+            ['(truncate-quotient 5 2)', 2],
+            ['(truncate-quotient -5 2)', -2],
+            ['(truncate-quotient 5 -2)', -2],
+            ['(truncate-quotient -5 -2)', 2],
+            ['(quotient 5 2)', 2],
+            ['(quotient -5 2)', -2],
+            ['(quotient 5 -2)', -2],
+            ['(quotient -5 -2)', 2]            
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result).to eq(expectation)
+          end
+        end
+
+        it 'should implement the truncate-remainder procedure' do
+          checks = [
+            ['(truncate-remainder 5 2)', 1],
+            ['(truncate-remainder -5 2)', -1],
+            ['(truncate-remainder 5 -2)', 1],
+            ['(truncate-remainder -5 -2)', -1],
+            ['(remainder 5 2)', 1],
+            ['(remainder -5 2)', -1],
+            ['(remainder 5 -2)', 1],
+            ['(remainder -5 -2)', -1]            
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result).to eq(expectation)
+          end
+        end
+      
+      it 'should implement the test-equal procedure' do
+        checks = [
+          ["(test-equal (cons 1 2) (cons 1 2))", true]
+        ]
+        checks.each do |(skeem_expr, expectation)|
+          result = subject.run(skeem_expr)
+          expect(result).to eq(expectation)
+        end
+      end      
     end # context
 
     context 'Second-order functions' do

data/spec/skeem/primitive/primitive_builder_spec.rb

@@ -35,6 +35,8 @@ SKEEM
             ['(+)', 0], # '+' as nullary operator. Example from section 6.2.6
             ['(+ -3)', -3], # '+' as unary operator
             ['(+ 3 4)', 7], # '+' as binary operator. Example from section 4.1.3
+            ['(+ 1/2 2/3)', Rational(7,6)],
+            ['(+ 1/2 3)', Rational(7,2)],
             ['(+ 2 2.34)', 4.34]
           ].each do |(expr, predicted)|
             result = subject.run(expr)
@@ -45,6 +47,7 @@ SKEEM
         it 'should implement the minus operator' do
           [
             ['(- 3)', -3], # '-' as unary operator (= sign change)
+            ['(- -2/3)', Rational(2, 3)],
             ['(- 3 4)', -1], # '-' as binary operator. Example from section 6.2.6
             ['(- 3 4 5)', -6] # '-' as variadic operator. Example from section 6.2.6
           ].each do |(expr, predicted)|
@@ -58,6 +61,7 @@ SKEEM
             ['(*)', 1], # '*' as nullary operator. Example from section 6.2.6
             ['(* 4)', 4], # '*' as unary operator. Example from section 6.2.6
             ['(* 5 8)', 40], # '*' as binary operator.
+            ['(* 2/3 5/7)', Rational(10, 21)],
             ['(* 2 3 4 5)', 120] # '*' as variadic operator.
           ].each do |(expr, predicted)|
             result = subject.run(expr)
@@ -67,28 +71,45 @@ SKEEM
 
         it 'should implement the division operator' do
           [
-            ['(/ 3)', 1.0/3], # '/' as unary operator (= inverse of argument)
-            ['(/ 3 4)', 3.0/4], # '/' as binary operator.
-            ['(/ 3 4 5)', 3.0/20] # '/' as variadic operator. Example from section 6.2.6
+            ['(/ 3)', Rational(1, 3)], # '/' as unary operator (= inverse of argument)
+            ['(/ 3/4)', Rational(4, 3)],
+            ['(/ 3 4)', Rational(3, 4)], # '/' as binary operator.
+            ['(/ 2/3 5/7)', Rational(14, 15)],
+            ['(/ 3 4 5)', Rational(3, 20)] # '/' as variadic operator. Example from section 6.2.6
           ].each do |(expr, predicted)|
             result = subject.run(expr)
             expect(result).to eq(predicted)
           end
+
+          result = subject.run('(/ 3 4.5)')
+          expect(result.value).to be_within(0.000001).of(0.66666667)
         end
 
-        it 'should implement the floor-remainder (modulo) procedure' do
+        it 'should implement the floor/ procedure' do
           checks = [
-            ['(floor-remainder 16 4)', 0], # Binary procedure.
-            ['(floor-remainder 5 2)', 1],
-            ['(floor-remainder -45.0 7)', 4.0],
-            ['(floor-remainder 10.0 -3.0)', -2.0],
-            ['(floor-remainder -17 -9)', -8]
+            ['(floor/ 5 2)', [2, 1]], # Binary procedure.
+            ['(floor/ -5 2)', [-3, 1]],
+            ['(floor/ 5 -2)', [-3, -1]],
+            ['(floor/ -5 -2)', [2, -1]]
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
-            expect(result).to eq(expectation)
+            expect([result.car, result.cdr]).to eq(expectation)
           end
         end
+        
+        it 'should implement the truncate/ procedure' do
+          checks = [
+            ['(truncate/ 5 2)', [2, 1]], # Binary procedure.
+            ['(truncate/ -5 2)', [-2, -1]],
+            ['(truncate/ 5 -2)', [-2, 1]],
+            ['(truncate/ -5 -2)', [2, -1]]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect([result.car, result.cdr]).to eq(expectation)
+          end
+        end        
       end # context
 
       context 'Comparison operators' do
@@ -228,12 +249,37 @@ SKEEM
             expect(result).to eq(expectation)
           end
         end
+
+        it 'should implement the max procedure' do
+          checks = [
+            ['(max 3 4)', 4],
+            ['(max 3.9 4)', 4],
+            ['(max 4 -7 2 0 -6)', 4]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result).to eq(expectation)
+          end
+        end
+
+        it 'should implement the min procedure' do
+          checks = [
+            ['(min 3 4)', 3],
+            ['(min 3.9 4)', 3.9],
+            ['(min 4 -7 2 0 -6)', -7]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result).to eq(expectation)
+          end
+        end
       end # context
 
       context 'Number procedures:' do
         it 'should implement the number? predicate' do
           checks = [
             ['(number? 3.1)', true],
+            ['(number? 22/7)', true],
             ['(number? 3)', true],
             ['(number? "3")', false],
             ['(number? #t)', false]
@@ -247,6 +293,7 @@ SKEEM
         it 'should implement the real? predicate' do
           checks = [
             ['(real? 3.1)', true],
+            ['(real? 22/7)', true],
             ['(real? 3)', true],
             ['(real? "3")', false],
             ['(real? #t)', false]
@@ -257,10 +304,26 @@ SKEEM
           end
         end
 
+        it 'should implement the rational? predicate' do
+          checks = [
+            ['(rational? 3.1)', false],
+            ['(rational? 3.0)', true],
+            ['(rational? 22/7)', true],
+            ['(rational? 3)', true],
+            ['(rational? "3")', false],
+            ['(rational? #t)', false]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result).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.0)', true],
+            ['(integer? 22/7)', false],
             ['(integer? 3)', true],
             ['(integer? "3")', false],
             ['(integer? #t)', false]
@@ -274,6 +337,7 @@ SKEEM
         it 'should implement the number->string procedure' do
           checks = [
             ['(number->string 3.4)', '3.4'],
+            ['(number->string 22/7)', '22/7'],
             ['(number->string 1e2)', '100.0'],
             ['(number->string 1e-23)', '1.0e-23'],
             ['(number->string -7)', '-7']

data/spec/skeem/tokenizer_spec.rb

@@ -82,6 +82,29 @@ module Skeem
       end
     end # context
 
+    context 'Rational literals recognition:' do
+      it 'should tokenize rational in default radix 10' do
+        tests = [
+          # couple [raw input, expected]
+          ['1/2', Rational(1, 2)],
+          ['-22/7', -Rational(22, 7)],
+        ]
+
+        tests.each do |(input, prediction)|
+          subject.reinitialize(input)
+          token = subject.tokens.first
+          expect(token.terminal).to eq('RATIONAL')
+          expect(token.lexeme).to eq(prediction)
+        end
+        
+        # Special case: implicit promotion to integer
+        subject.reinitialize('8/4')
+        token = subject.tokens.first
+        expect(token.terminal).to eq('INTEGER')
+        expect(token.lexeme).to eq(2)        
+      end
+    end # context
+
     context 'Real number recognition:' do
       it 'should tokenize real numbers' do
         tests = [
@@ -211,7 +234,7 @@ module Skeem
         expect(token.terminal).to eq('STRING_LIT')
         expect(token.lexeme).to eq('Second text')
       end
-      
+
       it 'should cope with nested block comments' do
         input = '"First text" #| One #| Two |# comment #| Three |# |# "Second text"'
         subject.reinitialize(input)
@@ -223,7 +246,7 @@ module Skeem
         token = tokens[1]
         expect(token.terminal).to eq('STRING_LIT')
         expect(token.lexeme).to eq('Second text')
-      end      
+      end
     end
 
     context 'Scanning Scheme sample code' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skeem
 version: !ruby/object:Gem::Version
-  version: 0.2.09
+  version: 0.2.10
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-10 00:00:00.000000000 Z
+date: 2019-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley