skeem 0.0.19 → 0.0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9cb4724d17594667921a2ccd39d5c39891edf55b
-  data.tar.gz: e5ac55b88a2c71fb84e5752881e11c36546e5c98
+  metadata.gz: 91492f1d990da9deecf2146b21c13a5721cbf327
+  data.tar.gz: 06355e700c51894615aea3c34c7f26794a2482b4
 SHA512:
-  metadata.gz: f70733db86074f7828e19bfb069f957372bfc10e95d2fa0d85484de418b147d6392ff357f533977d6d10db4fa08a29372f916274dd2d192fa6bdd8887561f608
-  data.tar.gz: 5ed2a9db63d57adb2d93cb1c99d4b5d40a452f5174531d3c06522c80c6f1914c34fd4e97ca02059e3c733a227d3dfb22c9eeba363b01dadb7d75786ad90f3c48
+  metadata.gz: eb0d9f83f9816fbc881fef46b75e9587111539e3f4254772478e3e05bcb1c4fcd26d6dc16d83053f41c2fab55fe96e1d5d4cc1b02a7fc120218d09dcaa000088
+  data.tar.gz: cad77c7dab37087ff75202d2429d5213dd1ccf04e04d6a45993f41f9dc7ef587b897e2c677e10f1eb3d800c46f47a742f2378d95b2c020edb0f2d2da34d5171f

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## [0.0.20] - 2018-10-21
+### Added
+- Added support for quotation: (quote foo) or 'foo
+- Added support for vectors #( 1 2 3 "foo")
+- Added primitive procedures `vector?`, `vector`, `vector-length`  
+
+### Changed
+- File `README.md` enhanced with detailed implementation status.
+- Class `PrimitiveBuilder` in addition to new Skeem procedures, the class was vastly refactored.
+- Class `Tokenizer` extended to cope with quotation and vectors.
+
 ## [0.0.19] - 2018-10-15
 Added primitive procedures `list?`, `null?`, `length`
 

data/README.md

@@ -1,5 +1,6 @@
 # Skeem
 [![Linux Build Status](https://travis-ci.org/famished-tiger/Skeem.svg?branch=master)](https://travis-ci.org/famished-tiger/Skeem)
+[![Build status](https://ci.appveyor.com/api/projects/status/qs19wn6o6bpo8lm6?svg=true)](https://ci.appveyor.com/project/famished-tiger/skeem)
 [![Gem Version](https://badge.fury.io/rb/skeem.svg)](https://badge.fury.io/rb/skeem)
 [![License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)](https://github.com/famished-tiger/Skeem/blob/master/LICENSE.txt)
 
@@ -91,9 +92,69 @@ At this stage, the gem consists of a bare-bones interpreter.
   SKEEM
 
   result = schemer.run(scheme_code)
-  puts result.value # => 9332621544394415268169923885626670049071596826438162146859296389521759999322991560894146397615651828625369792082722375825118521091686400000000000000000000000 
+  puts result.value # => 9332621544394415268169923885626670049071596826438162146859296389521759999322991560894146397615651828625369792082722375825118521091686400000000000000000000000
 ```
 
+## Currently implemented R7RS features
+### Data type literals
+- Booleans: `#t`, `#true`, `#f`, `#false`
+- Of the number hierarchy:  
+  `real` (e.g. 2.718, 6.671e-11),  
+  `integer` (42, -3)
+- Strings: `"Hello, world."`
+- Identifiers (symbols): `really-cool-procedure`
+- Vectors: `#(1 2 "three")`
+
+### Scheme Expressions
+- Variable references
+- Procedure calls
+- Lambda expressions
+- If conditionals
+- Definitions
+
+### Standard syntactic forms
+#### define  
+__Purpose:__ Create a new variable and bind an expression/value to it.  
+__Syntax:__   
+* (define <identifier\> <expression\>)
+
+#### if  
+__Purpose:__ Conditional evaluation based on a test expression.  
+__Syntax:__   
+* (if <test\> <consequent\> <alternate\>)  
+
+
+#### lambda  
+__Purpose:__ Definition of a procedure.  
+__Syntax:__   
+* (lambda <formals\> <body\>)
+
+### Standard library
+This section lists the implemented standard procedures
+
+#### Boolean procedures
+* `boolean?`, `not`
+
+#### Numerical operations
+* Number-level: `number?`, `real?`, `integer?`, `zero?`, `+`, `-`, `*`, `/`, `=`, `square`
+* Real-level: `positive?`, `negative?`, `<`, `>`, `<=`, `>=`, `abs`, `floor-remainder`
+* Integer-level: `even?`, `odd?`
+
+#### List procedures
+* `list?`, `null?`, `list`, `length`
+
+#### String procedures
+* `string?`
+
+#### Symbol procedures
+* `symbol?`
+
+#### Vector procedures
+* `vector?`, `vector`, `vector-length`
+
+#### Input/output procedures
+* `newline`
+
 Roadmap:
 - Extend language support
 - Implement REPL
@@ -107,12 +168,9 @@ Roadmap:
 Good to know:
 Online book: [The Scheme Programming Language (4th Ed.)](https://www.scheme.com/tspl4/). Remark: covers an older version of Scheme.
 
-## Implemented Scheme R7RS features:
 
-### Literals
-* Boolean literals: `#t`, `#true`, `#f` and `#false`
-* Numeric literals for integers and reals.
-* `string` and `identifier` literals
+
+
 
 ## Other similar Ruby projects
 __Skeem__ isn't the sole implementation of the Scheme language in Ruby.  

data/lib/skeem/grammar.rb

@@ -9,9 +9,10 @@ module Skeem
   # Names of grammar elements are based on the R7RS documentation
   builder = Rley::Syntax::GrammarBuilder.new do
     # Delimiters, separators...
-    # add_terminals('APOSTROPHE', 'BACKQUOTE')
+    add_terminals('APOSTROPHE') #, 'BACKQUOTE')
     add_terminals('LPAREN', 'RPAREN')
     add_terminals('PERIOD')
+    add_terminals('VECTOR_BEGIN')
 
     # Literal values...
     add_terminals('BOOLEAN', 'INTEGER', 'REAL')
@@ -19,6 +20,7 @@ module Skeem
 
     # Keywords...
     add_terminals('DEFINE', 'IF', 'LAMBDA')
+    add_terminals('QUOTE')
 
     rule('program' => 'cmd_or_def_plus').as 'main'
     rule('cmd_or_def_plus' => 'cmd_or_def_plus cmd_or_def').as 'multiple_cmd_def'
@@ -33,10 +35,30 @@ module Skeem
     rule 'expression' =>  'procedure_call'
     rule 'expression' =>  'lambda_expression'
     rule 'expression' =>  'conditional'
+    rule 'literal' => 'quotation'
     rule 'literal' => 'self-evaluating'
+    rule('quotation' => 'APOSTROPHE datum').as 'quotation_abbrev'
+    rule('quotation' => 'LPAREN QUOTE datum RPAREN').as 'quotation'
     rule 'self-evaluating' => 'BOOLEAN'
     rule 'self-evaluating' => 'number'
     rule 'self-evaluating' => 'STRING_LIT'
+    rule 'self-evaluating' => 'vector'
+    rule 'datum' => 'simple_datum'
+    rule 'datum' => 'compound_datum'
+    rule 'simple_datum' => 'BOOLEAN'
+    rule 'simple_datum' => 'number'
+    rule 'simple_datum' => 'STRING_LIT' 
+    rule 'simple_datum' => 'symbol'
+    rule 'compound_datum' => 'list'
+    rule 'compound_datum' => 'vector'
+    rule 'list' => 'LPAREN datum_star RPAREN'
+    rule 'list' => 'LPAREN datum_plus PERIOD datum RPAREN'
+    rule('vector' => 'VECTOR_BEGIN datum_star RPAREN').as 'vector'
+    rule('datum_plus' => 'datum_plus datum').as 'multiple_datums'
+    rule('datum_plus' => 'datum').as 'last_datum'    
+    rule('datum_star' => 'datum_star datum').as 'datum_star'
+    rule('datum_star' => []).as 'no_datum_yet'
+    rule 'symbol' => 'IDENTIFIER'
     rule('procedure_call' => 'LPAREN operator RPAREN').as 'proc_call_nullary'
     rule('procedure_call' => 'LPAREN operator operand_plus RPAREN').as 'proc_call_args'
     rule('operand_plus' => 'operand_plus operand').as 'multiple_operands'

data/lib/skeem/primitive/primitive_builder.rb

@@ -13,30 +13,31 @@ module Skeem
         add_string_procedures(aRuntime)
         add_symbol_procedures(aRuntime)
         add_list_procedures(aRuntime)
+        add_vector_procedures(aRuntime)
         add_io_procedures(aRuntime)
         add_special_procedures(aRuntime)
       end
 
       private
-      
+
       def nullary
-        SkmArity.new(0, 0) 
+        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, '*') 
+        SkmArity.new(1, '*')
       end
 
       def add_arithmetic(aRuntime)
@@ -56,30 +57,37 @@ module Skeem
       end
 
       def add_number_predicates(aRuntime)
-        create_number?(aRuntime)
-        create_real?(aRuntime)
-        create_integer?(aRuntime)
+        create_object_predicate(aRuntime, 'number?')
+        create_object_predicate(aRuntime, 'real?')
+        create_object_predicate(aRuntime, 'integer?')
       end
 
       def add_boolean_procedures(aRuntime)
         create_not(aRuntime)
-        create_boolean?(aRuntime)
+        create_object_predicate(aRuntime, 'boolean?')
       end
 
       def add_string_procedures(aRuntime)
-        create_string?(aRuntime)
+        create_object_predicate(aRuntime, 'string?')
       end
 
       def add_symbol_procedures(aRuntime)
-        create_symbol?(aRuntime)
+        create_object_predicate(aRuntime, 'symbol?')
       end
-      
+
       def add_list_procedures(aRuntime)
-        create_list?(aRuntime)
-        create_null?(aRuntime)
+        create_object_predicate(aRuntime, 'list?')
+        create_object_predicate(aRuntime, 'null?')
         create_length(aRuntime)
       end
 
+      def add_vector_procedures(aRuntime)
+        create_object_predicate(aRuntime, 'vector?')
+        create_vector(aRuntime)
+        create_vector_length(aRuntime)
+        # create_vector_ref(aRuntime)
+      end
+
       def add_io_procedures(aRuntime)(aRuntime)
         create_newline(aRuntime)
       end
@@ -135,7 +143,7 @@ module Skeem
         define_primitive_proc(aRuntime, '*', zero_or_more, primitive)
       end
 
-      
+
       def create_divide(aRuntime)
         primitive = ->(runtime, first_operand, arglist) do
           first_one = first_operand.evaluate(runtime)
@@ -155,19 +163,19 @@ module Skeem
           end
           to_skm(raw_result)
         end
-        
+
         define_primitive_proc(aRuntime, '/', one_or_more, primitive)
       end
 
       def create_modulo(aRuntime)
-          primitive = ->(runtime, argument1, argument2) do 
+          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
 
-        define_primitive_proc(aRuntime, 'floor-remainder', binary, primitive) 
+        define_primitive_proc(aRuntime, 'floor-remainder', binary, primitive)
       end
 
       def create_equal(aRuntime)
@@ -176,7 +184,7 @@ module Skeem
           if arglist.empty?
             to_skm(true)
           else
-            operands = evaluate_array(arglist, runtime)         
+            operands = evaluate_array(arglist, runtime)
             first_value = first_one.value
             all_equal = operands.all? { |elem| first_value == elem.value }
             to_skm(all_equal)
@@ -190,7 +198,7 @@ module Skeem
         primitive = ->(runtime, first_operand, arglist) do
           if arglist.empty?
             to_skm(false)
-          else        
+          else
             operands = [first_operand.evaluate(runtime)]
             operands.concat(evaluate_array(arglist, runtime))
             result = true
@@ -208,7 +216,7 @@ module Skeem
         primitive = ->(runtime, first_operand, arglist) do
           if arglist.empty?
             to_skm(false)
-          else        
+          else
             operands = [first_operand.evaluate(runtime)]
             operands.concat(evaluate_array(arglist, runtime))
             result = true
@@ -226,7 +234,7 @@ module Skeem
         primitive = ->(runtime, first_operand, arglist) do
           if arglist.empty?
             to_skm(true)
-          else        
+          else
             operands = [first_operand.evaluate(runtime)]
             operands.concat(evaluate_array(arglist, runtime))
             result = true
@@ -244,7 +252,7 @@ module Skeem
         primitive = ->(runtime, first_operand, arglist) do
           if arglist.empty?
             to_skm(true)
-          else        
+          else
             operands = [first_operand.evaluate(runtime)]
             operands.concat(evaluate_array(arglist, runtime))
             result = true
@@ -258,33 +266,6 @@ module Skeem
         define_primitive_proc(aRuntime, '>=', one_or_more, primitive)
       end
 
-      def create_number?(aRuntime)
-         primitive = ->(runtime, object) do
-          arg_evaluated = object.evaluate(runtime)
-          to_skm(arg_evaluated.number?)
-        end
-
-        define_primitive_proc(aRuntime, 'number?', unary, primitive)
-      end
-
-      def create_real?(aRuntime)
-        primitive = ->(runtime, arg) do
-          arg_evaluated = arg.evaluate(runtime)
-          to_skm(arg_evaluated.real?)
-        end
-
-        define_primitive_proc(aRuntime, 'real?', unary, primitive)
-      end
-
-      def create_integer?(aRuntime)
-        primitive = ->(runtime, arg) do
-          arg_evaluated = arg.evaluate(runtime)
-          to_skm(arg_evaluated.integer?)
-        end
-
-        define_primitive_proc(aRuntime, 'integer?', unary, primitive)
-      end
-
       def create_not(aRuntime)
         primitive = ->(runtime, arg) do
           arg_evaluated = arg.evaluate(runtime)
@@ -294,67 +275,57 @@ module Skeem
             to_skm(false)
           end
         end
-        
+
         define_primitive_proc(aRuntime, 'not', unary, primitive)
       end
 
-      def create_boolean?(aRuntime)
+      def create_length(aRuntime)
         primitive = ->(runtime, arg) do
           arg_evaluated = arg.evaluate(runtime)
-          to_skm(arg_evaluated.boolean?)
+          check_argtype(arg_evaluated, SkmList, 'list', 'length')
+          to_skm(arg_evaluated.length)
         end
 
-        define_primitive_proc(aRuntime, 'boolean?', unary, primitive)
+        define_primitive_proc(aRuntime, 'length', unary, primitive)
       end
 
-      def create_string?(aRuntime)
-        primitive = ->(runtime, arg) do
-          arg_evaluated = arg.evaluate(runtime)
-          to_skm(arg_evaluated.string?)
-        end
-
-        define_primitive_proc(aRuntime, 'string?', unary, primitive)
-      end
+      def create_vector(aRuntime)
+        primitive = ->(runtime, arglist) do
+          if arglist.empty?
+            elements = []
+          else
+            elements = evaluate_array(arglist, aRuntime)
+          end
 
-      def create_symbol?(aRuntime)
-        primitive = ->(runtime, arg) do
-          arg_evaluated = arg.evaluate(runtime)
-          to_skm(arg_evaluated.symbol?)
+          SkmVector.new(elements)
         end
 
-        define_primitive_proc(aRuntime, 'symbol?', unary, primitive)
+        define_primitive_proc(aRuntime, 'vector', zero_or_more, primitive)
       end
-      
-      def create_list?(aRuntime)
+
+      def create_vector_length(aRuntime)
         primitive = ->(runtime, arg) do
           arg_evaluated = arg.evaluate(runtime)
-          to_skm(arg_evaluated.list?)
+          check_argtype(arg_evaluated, SkmVector, 'vector', 'vector-length')
+          to_skm(arg_evaluated.length)
         end
 
-        define_primitive_proc(aRuntime, 'list?', unary, primitive)
+        define_primitive_proc(aRuntime, 'vector-length', unary, primitive)
       end
 
-      def create_null?(aRuntime)
-        primitive = ->(runtime, arg) do
-          arg_evaluated = arg.evaluate(runtime)
-          to_skm(arg_evaluated.null?)
-        end
-
-        define_primitive_proc(aRuntime, 'null?', unary, primitive)
-      end       
-      
-      def create_length(aRuntime)
-        primitive = ->(runtime, arg) do
-          arg_evaluated = arg.evaluate(runtime)
-          unless arg_evaluated.kind_of?(SkmList)
-            msg1 = "Procedure 'length': list argument required,"
-            msg2 = "but got #{arg_evaluated.value}"
-            raise StandardError, msg1 + ' ' + msg2
-          end
-          to_skm(arg_evaluated.length)
+      def create_vector_ref(aRuntime)
+          # argument 1: a vector, argument 2: an index(integer)
+          primitive = ->(runtime, aVector, anIndex) do
+          vector = aVector.evaluate(runtime)
+          check_argtype(vector, SkmVector, 'vector', 'vector-ref')
+          index = anIndex.evaluate(runtime)
+          check_argtype(index, SkmInteger, 'integer', 'vector-ref')
+          # TODO: index checking
+          raw_result = vector.elements[index.value]
+          to_skm(raw_result)
         end
 
-        define_primitive_proc(aRuntime, 'length', unary, primitive)
+        define_primitive_proc(aRuntime, 'vector-ref', binary, primitive)
       end
 
       def create_newline(aRuntime)
@@ -374,6 +345,16 @@ module Skeem
         define_primitive_proc(aRuntime, 'debug', nullary, primitive)
       end
 
+      def create_object_predicate(aRuntime, predicate_name, msg_name = nil)
+        msg_name = predicate_name if msg_name.nil?
+        primitive = ->(runtime, arg) do
+          arg_evaluated = arg.evaluate(runtime)
+          to_skm(arg_evaluated.send(msg_name))
+        end
+
+        define_primitive_proc(aRuntime, predicate_name, unary, primitive)
+      end
+
 
       def def_procedure(aRuntime, pairs)
         pairs.each_slice(2) do |(name, code)|
@@ -381,7 +362,7 @@ 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)
@@ -390,14 +371,22 @@ module Skeem
       def define(aRuntime, aKey, anEntry)
         aRuntime.define(aKey, anEntry)
       end
-      
+
       def evaluate_array(anArray, aRuntime)
         anArray.map { |elem| elem.evaluate(aRuntime) }
-      end      
-      
+      end
+
       def evaluate_tail(anArray, aRuntime)
         evaluate_array(anArray.drop(1), aRuntime)
-      end      
+      end
+
+      def check_argtype(argument, requiredRubyClass, requiredSkmType, aProcName)
+          unless argument.kind_of?(requiredRubyClass)
+            msg1 = "Procedure '#{aProcName}': #{requiredSkmType} argument required,"
+            msg2 = "but got #{argument.value}"
+            raise StandardError, msg1 + ' ' + msg2
+          end
+      end
     end # module
   end # module
 end # module

data/lib/skeem/s_expr_builder.rb

@@ -73,7 +73,32 @@ module Skeem
     def reduce_variable_reference(_production, aRange, _tokens, theChildren)
       SkmVariableReference.new(aRange, theChildren[0])
     end
+    
+    # rule('quotation' => 'APOSTROPHE datum').as 'quotation_abbrev'
+    def reduce_quotation_abbrev(_production, aRange, _tokens, theChildren)
+      SkmQuotation.new(theChildren[1])
+    end      
 
+    # rule('quotation' => 'LPAREN QUOTE datum RPAREN').as 'quotation'
+    def reduce_quotation(_production, aRange, _tokens, theChildren)
+      SkmQuotation.new(theChildren[2])
+    end
+    
+    # rule('vector' => 'VECTOR_BEGIN datum_star RPAREN').as 'vector'
+    def reduce_vector(_production, aRange, _tokens, theChildren)
+      SkmVector.new(theChildren[1])
+    end    
+    
+    # rule('datum_star' => 'datum_star datum').as 'datum_star'
+    def reduce_datum_star(_production, aRange, _tokens, theChildren)
+      theChildren[0] << theChildren[1]
+    end    
+    
+    # rule('datum_star' => []).as 'no_datum_yet'
+    def reduce_no_datum_yet(_production, aRange, _tokens, theChildren)
+      []
+    end
+    
     # rule('procedure_call' => 'LPAREN operator RPAREN').as 'proc_call_nullary'
     def reduce_proc_call_nullary(_production, aRange, _tokens, theChildren)
       ProcedureCall.new(aRange, theChildren[1], [])

data/lib/skeem/s_expr_nodes.rb

@@ -56,6 +56,10 @@ module Skeem
     def null?
       false
     end
+    
+    def vector?
+      false
+    end
 
     # Abstract method.
     # Part of the 'visitee' role in Visitor design pattern.
@@ -247,6 +251,42 @@ module Skeem
     alias to_a members  
     alias rest tail
   end # class
+  
+  class SkmVector < SkmElement
+    attr_accessor(:elements)
+    extend Forwardable
+
+    def_delegators :@elements, :each, :length, :empty?, :size    
+    
+    def initialize(theElements)
+      super(nil)
+      @elements = theElements.nil? ? [] : theElements
+    end
+    
+    def vector?
+      true
+    end
+
+    def evaluate(aRuntime)
+      elements_evaluated = elements.map { |elem| elem.evaluate(aRuntime) }
+      SkmVector.new(elements_evaluated)
+    end    
+  
+  end # class
+  
+  
+  class SkmQuotation < SkmElement
+    attr_accessor(:datum)  
+    
+    def initialize(aDatum)
+      super(nil)
+      @datum = aDatum
+    end
+
+    def evaluate(aRuntime)
+      datum
+    end
+  end # class
 
   class SkmDefinition < SkmElement
     attr_reader :variable

data/lib/skeem/tokenizer.rb

@@ -23,15 +23,17 @@ module Skeem
       '`' => 'BACKQUOTE',
       '(' => 'LPAREN',
       ')' => 'RPAREN',
-      '.' => 'PERIOD'
+      '.' => 'PERIOD',
+      '#(' => 'VECTOR_BEGIN'
     }.freeze
 
     # Here are all the SRL keywords (in uppercase)
     @@keywords = %w[
       BEGIN
-      IF
       DEFINE
+      IF
       LAMBDA
+      QUOTE
     ].map { |x| [x, x] } .to_h
 
     class ScanError < StandardError; end
@@ -74,10 +76,10 @@ module Skeem
       if "()'`".include? curr_ch
         # Delimiters, separators => single character token
         token = build_token(@@lexeme2name[curr_ch], scanner.getch)
-      elsif (lexeme = scanner.scan(/(?:\.)(?=\s|[|()";]|$)/)) # Single char occurring alone
+      elsif (lexeme = scanner.scan(/(?:\.)(?=\s)/)) # Single char occurring alone
         token = build_token('PERIOD', lexeme)
-      elsif (lexeme = scanner.scan(/#(?:t|f|true|false)(?=\s|[|()";]|$)/))
-        token = build_token('BOOLEAN', lexeme)
+      elsif (lexeme = scanner.scan(/#(?:(?:true)|(?:false)|(?:u8)|[\\\(tfeiodx]|(?:\d+[=#]))/))
+        token = cardinal_token(lexeme)        
       elsif (lexeme = scanner.scan(/[+-]?[0-9]+(?=\s|[|()";]|$)/))
         token = build_token('INTEGER', lexeme) # Decimal radix
       elsif (lexeme = scanner.scan(/[+-]?[0-9]+(?:\.[0-9]+)?(?:(?:e|E)[+-]?[0-9]+)?/))
@@ -109,6 +111,31 @@ module Skeem
 
       return token
     end
+    
+=begin
+#t #f These are the boolean constants (section 6.3), along
+with the alternatives #true and #false.
+#\ This introduces a character constant (section 6.6).
+#( This introduces a vector constant (section 6.8). Vector
+constants are terminated by ) .
+#u8( This introduces a bytevector constant (section 6.9).
+Bytevector constants are terminated by ) .
+#e #i #b #o #d #x These are used in the notation for
+numbers (section 6.2.5).
+#<n>= #<n># These are used for labeling and referencing
+other literal data (section 2.4).
+        # token = build_token('BOOLEAN', lexeme)
+=end    
+    def cardinal_token(aLexeme)
+      case aLexeme
+      when /^#true|false|t|f$/
+        token = build_token('BOOLEAN', aLexeme)
+      when '#('
+        token = build_token(@@lexeme2name[aLexeme], aLexeme)
+      end
+      
+      return token
+    end
 
     def build_token(aSymbolName, aLexeme, aFormat = :default)
       begin

data/lib/skeem/version.rb

@@ -1,3 +1,3 @@
 module Skeem
-  VERSION = '0.0.19'.freeze
+  VERSION = '0.0.20'.freeze
 end

data/spec/skeem/interpreter_spec.rb

@@ -83,6 +83,22 @@ module Skeem
           expect(result.value).to eq(predicted)
         end
       end
+      
+      it 'should evaluate vector of constants' do
+        source = '#(2018 10 20 "Sat")'
+        result = subject.run(source)
+        expect(result).to be_kind_of(SkmVector)
+        predictions = [
+          [SkmInteger, 2018],
+          [SkmInteger, 10],
+          [SkmInteger, 20],
+          [SkmString, 'Sat']
+        ]
+        predictions.each_with_index do |(type, value), index|
+          expect(result.elements[index]).to be_kind_of(type)
+          expect(result.elements[index].value).to eq(value)
+        end        
+      end
     end # context
 
     context 'Built-in primitives' do
@@ -115,7 +131,7 @@ SKEEM
       end
 
       it 'should implement the complete conditional form' do
-         checks = [
+        checks = [
           ['(if (> 3 2) "yes" "no")', 'yes'],
           ['(if (> 2 3) "yes" "no")', 'no']
         ]
@@ -133,6 +149,39 @@ SKEEM
         expect(result.value).to eq(1)
       end
 
+      it 'should implement the quotation of constant literals' do
+         checks = [
+          ['(quote a)', 'a'],
+          ['(quote 145932)', 145932],
+          ['(quote "abc")', 'abc'],
+          ['(quote #t)', true],
+          ["'a", 'a'],
+          ["'145932", 145932],
+          ["'\"abc\"", 'abc'],
+          ["'#t", true]          
+        ]
+        checks.each do |(skeem_expr, expectation)|
+          result = subject.run(skeem_expr)
+          expect(result.value).to eq(expectation)
+        end
+      end
+
+      it 'should implement the quotation of vector' do
+        source = '(quote #(a b c))'
+        result = subject.run(source)
+        expect(result).to be_kind_of(SkmVector)
+        predictions = [
+          [SkmIdentifier, 'a'],
+          [SkmIdentifier, 'b'],
+          [SkmIdentifier, 'c']
+        ]
+        predictions.each_with_index do |(type, value), index|
+          expect(result.elements[index]).to be_kind_of(type)
+          expect(result.elements[index].value).to eq(value)
+        end        
+      end      
+      
+
       it 'should implement the lambda function with one arg' do
         source = <<-SKEEM
   ; Simplified 'abs' function implementation
@@ -196,7 +245,7 @@ SKEEM
         expect(result).to be_kind_of(SkmList)
         expect(result.length).to eq(4)
       end
-      
+
       it 'should support procedures with dotted pair arguments' do
         # Example from R7RS section 4.1.4
         source = '((lambda (x y . z) z) 3 4 5 6)'
@@ -205,9 +254,7 @@ SKEEM
         expect(result.length).to eq(2)
         expect(result.head.value).to eq(5)
         expect(result.last.value).to eq(6)
-      end      
-      
-
+      end
 =begin
       it 'should implement the compact define + lambda syntax' do
           source = <<-SKEEM
@@ -349,7 +396,7 @@ SKEEM
           expect(result.value).to eq(expectation)
         end
       end
-      
+
       it 'should implement the list procedure' do
         checks = [
           ['(list)', []],
@@ -360,7 +407,7 @@ SKEEM
           result = subject.run(skeem_expr)
           expect(result.members.map(&:value)).to eq(expectation)
         end
-      end      
+      end
     end # context
   end # describe
 end # module

data/spec/skeem/primitive/primitive_builder_spec.rb

@@ -285,6 +285,57 @@ module Skeem
             expect(result.value).to eq(expectation)
           end
         end         
+      end # context  
+
+      context 'Vector procedures:' do          
+        it 'should implement the vector? procedure' do
+          checks = [
+            ['(vector? #f)', false],
+            ['(vector? 1)', false],
+            ['(vector? "bar")', false],
+            ['(vector? (list 1 2 3))', false],
+            ['(vector? #(1 #f "cool"))', true]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result.value).to eq(expectation)
+          end
+        end
+        
+        it 'should implement the vector procedure' do
+          source = '(vector)'
+          result = subject.run(source)
+          expect(result).to be_kind_of(SkmVector)
+          expect(result).to be_empty
+          
+          source = '(vector 1 2 3)'
+          result = subject.run(source)
+          expect(result).to be_kind_of(SkmVector)
+          expect(result.elements.map(&:value)).to eq([1, 2, 3])
+        end
+
+        it 'should implement the vector-length procedure' do
+          checks = [
+            ['(vector-length (vector))', 0],
+            ['(vector-length #())', 0],
+            ['(vector-length (vector 1))', 1],
+            ['(vector-length #(1))', 1],
+            ['(vector-length (vector 1 2))', 2],
+            ['(vector-length #(1 2))', 2],
+            ['(vector-length (vector 1 2 3))', 3]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result.value).to eq(expectation)
+          end
+        end 
+
+        # it 'should implement the vector-ref procedure' do
+          # source = "(vector-ref '#(1 1 2 3 5 8 13 21) 5)"
+          # result = subject.run(source)
+          # expect(result).to be_kind_of(SkmInteger)
+          # expect(result.value).to eq(8)         
+        # end         
       end # context      
       
       context 'IO procedures:' do          

data/spec/skeem/tokenizer_spec.rb

@@ -144,6 +144,26 @@ module Skeem
       end
     end # context
 
+    context 'Vector recognition' do
+      it 'should tokenize vectors' do
+        input = '#(0 -2 "Sue")'
+        subject.reinitialize(input)
+        predictions = [
+          ['VECTOR_BEGIN', '#(', 1],
+          ['INTEGER', 0, 3],
+          ['INTEGER', -2, 5],
+          ['STRING_LIT', 'Sue', 8],
+          ['RPAREN', ')', 13],
+        ]
+        tokens = subject.tokens
+        predictions.each_with_index do |(pr_terminal, pr_lexeme, pr_position), i|
+          expect(tokens[i].terminal).to eq(pr_terminal)
+          expect(tokens[i].lexeme).to eq(pr_lexeme)
+          expect(tokens[i].position.column).to eq(pr_position)
+        end
+      end
+    end
+
     context 'Semi-colon comments:' do
       it 'should skip heading comments' do
         input = "; Starting comment\n \"Some text\""

metadata

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