skeem 0.2.13 → 0.2.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56bd360c4a30ba9dae003a18c922b150924fd0471fe74f1196e75967161ed767
-  data.tar.gz: 90a2af34b4aa7b327656d7f889c94cead17d7a906d5db36e31d7a4ab3af5e920
+  metadata.gz: 4e35fb6742873b7c49a13e95be6143ae1a5cad7826f20aec0a02ba8dd98fa723
+  data.tar.gz: 7427071d91fa6578d37122bd953822e263f6eeba314d3d52bc5afd279052f08f
 SHA512:
-  metadata.gz: 87827300a4e54068a2e885ef74b5aba42d21d3639a933cb4060b02b39f55b74cc15697098134ca341b1c1bceb6c027c67e1b113de9c10d4455f3b3fed0e0f009
-  data.tar.gz: 3875d43e7c46826a7b6246f5ea07da250401281d54479bb933e0fe73b3da610ac43e1104bdacf975ad658d1ef2834a34a895b24142545cb201b59e028ad5aaa9
+  metadata.gz: 6f7229bba2d1cdffd83830124711b024452f82e4f3ba57219c476a4a6b07a67f3c84c13b7de2a22442f65ad82e7b414fcb429d3997047135f6e2105b2c42dece
+  data.tar.gz: 712805a13cff2128f340a0f75288ee81528e80114cac2815630e839c2e3c87c78efd5298a40bd47345edced3c597979a6be69b033db19478787da9f34a48af28

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+## [0.2.14] - 2019-06-29
+- Added derived expression ´do´ as an imperative iteration form. 
+- Added procedures: `vector-set!`
+
+### Added
+- Class `DoExpression` for the representation of the do loop expression
+- Class `SkmDelayedUpdateBinding` for implementation delayed updates of bindings
+
+### Changed
+- File `tokenizer.rb` Added new keyword `do`
+- File `grammar.rb` Added rules for the `do` expression syntax
+- File `primitive_builder.rb` Implementation primitive procedure `vector-set!`
+- File `README.md` Updated to reflect additions.
+
+### Fixed
+- Method `DatumDSL#to_datum` now supports an `SkmUndefined` input argument.
+
 ## [0.2.13] - 2019-06-22
 - Skeem now accepts integers in hexadecimal notation
 - Added procedures: `char->integer`, `integer->char`, `char=?`, `char<?`, `char>?`, `char<=?`, `char>=?`

data/README.md

@@ -189,9 +189,10 @@ Here are a few pointers for the Scheme programming language:
 - Variable references
 - Procedure calls
 - Lambda expressions
-- Conditionals (if, cond)
+- Conditionals (`if`, `cond`)
 - Definitions
 - Assignments
+- Iteration (`do`)
 - Control procedures
 
 ### Standard syntactic forms
@@ -231,6 +232,17 @@ __Syntax:__
 * (cond (<test\> <consequent\>)\+)  
 * (cond (<test\><consequent\>)* (else <alternate\>))
 
+#### do
+__Purpose:__ Sequential iteration  
+__Example__
+```scheme
+(do (
+    (vec (make-vector 5))
+    (i 0 (+ i 1)))
+  ((= i 5) vec)
+  (vector-set! vec i i)) ; => #(0 1 2 3 4)
+```
+
 #### let  
 __Purpose:__ Define one or more variable local to the block.  
 __Syntax:__   

data/lib/skeem/datum_dsl.rb

@@ -153,6 +153,8 @@ module Skeem
         when SkmPair  # Special case: not a PORO literal
           # One assumes that a Skeem list contains only Skeem datum objects
           SkmPair.create_from_a(aLiteral.to_a)
+        when SkmUndefined
+          aLiteral
         else
           raise StandardError, aLiteral.inspect
         end

data/lib/skeem/grammar.rb

@@ -19,7 +19,7 @@ module Skeem
     add_terminals('CHAR', 'STRING_LIT', 'IDENTIFIER')
 
     # Keywords...
-    add_terminals('BEGIN', 'COND', 'DEFINE', 'ELSE')
+    add_terminals('BEGIN', 'COND', 'DEFINE', 'DO', 'ELSE')
     add_terminals('IF', 'LAMBDA', 'LET', 'LET*')
     add_terminals('QUOTE', 'QUASIQUOTE', 'SET!')
     add_terminals('UNQUOTE', 'UNQUOTE-SPLICING')
@@ -106,6 +106,12 @@ module Skeem
     # As the R7RS grammar is too restrictive, 
     # the next rule was made more general than its standard counterpart
     rule('derived_expression' => 'LPAREN BEGIN body RPAREN').as 'begin_expression'
+    do_syntax = <<-END_SYNTAX
+    LPAREN DO LPAREN iteration_spec_star RPAREN 
+      LPAREN test do_result RPAREN
+      command_star RPAREN
+END_SYNTAX
+    rule('derived_expression' => do_syntax).as 'do_expression'
     rule 'derived_expression' => 'quasiquotation'
     rule('cond_clause_plus' => 'cond_clause_plus cond_clause').as 'multiple_cond_clauses'
     rule('cond_clause_plus' => 'cond_clause').as 'last_cond_clauses'
@@ -120,6 +126,14 @@ module Skeem
     rule('binding_spec_star' => 'binding_spec_star binding_spec').as 'multiple_binding_specs'
     rule('binding_spec_star' => []).as 'no_binding_spec_yet'
     rule('binding_spec' => 'LPAREN IDENTIFIER expression RPAREN').as 'binding_spec'
+    rule('iteration_spec_star' => 'iteration_spec_star iteration_spec').as 'multiple_iter_specs'
+    rule('iteration_spec_star' => []).as 'no_iter_spec_yet'
+    rule('iteration_spec' => 'LPAREN IDENTIFIER init step RPAREN').as 'iteration_spec_long'
+    rule('iteration_spec' => 'LPAREN IDENTIFIER init RPAREN').as 'iteration_spec_short'
+    rule('init' => 'expression')
+    rule('step' => 'expression')
+    rule 'do_result' => 'sequence'
+    rule('do_result' => []).as 'empty_do_result'
     rule 'qq_template' => 'simple_datum'
     rule 'qq_template' => 'list_qq_template'
     rule 'qq_template' => 'vector_qq_template'

data/lib/skeem/primitive/primitive_builder.rb

@@ -34,6 +34,10 @@ module Skeem
       def binary
         SkmArity.new(2, 2)
       end
+      
+      def ternary
+        SkmArity.new(3, 3)
+      end
 
       def zero_or_more
         SkmArity.new(0, '*')
@@ -143,6 +147,7 @@ module Skeem
         create_vector_length(aRuntime)
         create_make_vector(aRuntime)
         create_vector_ref(aRuntime)
+        create_vector_set(aRuntime)
         create_vector2list(aRuntime)
       end
 
@@ -999,7 +1004,6 @@ module Skeem
             filler = arglist.first.evaluate(runtime)
           end
           elements = Array.new(count.value, filler)
-
           vector(elements)
         end
 
@@ -1018,6 +1022,20 @@ module Skeem
 
         define_primitive_proc(aRuntime, 'vector-ref', binary, primitive)
       end
+      
+      def create_vector_set(aRuntime)
+          # Arguments aren't evaluated yet!...
+          primitive = ->(runtime, vector, k, object) do
+          index = k.evaluate(runtime)
+          check_argtype(vector, SkmVector, 'vector', 'vector-set!')
+          check_argtype(index, SkmInteger, 'integer', 'vector-set!')
+          # TODO: index checking
+          vector.members[index.value] = object
+          vector
+        end
+        
+        define_primitive_proc(aRuntime, 'vector-set!', ternary, primitive)
+      end
 
       def create_vector2list(aRuntime)
         primitive = ->(runtime, arg_evaluated) do

data/lib/skeem/primitive/primitive_procedure.rb

@@ -135,7 +135,7 @@ module Skeem
             result = code.send(:call, aRuntime, *args)
           end
         else # Fixed arity...
-          if identifier == 'set-car!' || identifier == 'set-cdr!'
+          if identifier.value =~ /^set-[a-zA-Z]+!/ || identifier.value =~ /[a-zA-Z]+-set!/
             # Defer evaluation inside the primitive
             result = code.send(:call, aRuntime, *operands)
           else

data/lib/skeem/s_expr_builder.rb

@@ -88,7 +88,7 @@ module Skeem
     # rule('expression' =>  'IDENTIFIER').as 'variable_reference'
     def reduce_variable_reference(_production, aRange, _tokens, theChildren)
       SkmVariableReference.new(aRange, theChildren[0])
-    end    
+    end
 
     # rule('quotation' => 'APOSTROPHE datum').as 'quotation_short'
     def reduce_quotation_short(_production, _range, _tokens, theChildren)
@@ -300,6 +300,21 @@ module Skeem
       SkmSequencingBlock.new(theChildren[2])
     end
 
+    # LPAREN DO LPAREN iteration_spec_star RPAREN
+      # LPAREN test do_result RPAREN
+      # command_star RPAREN
+    # rule('derived_expression' => do_syntax).as 'do_expression'
+    def reduce_do_expression(_production, _range, _tokens, theChildren)
+      # 3 => iteration_spec_star, 6 => test, 7 => do_result, 9 => command_star
+
+      # We reky on utility 'builder' object
+      worker = SkmDoExprBuilder.new(theChildren[3], theChildren[6],
+        theChildren[7], theChildren[9])
+      do_expression = worker.do_expression
+      body = { :defs => [], :sequence => do_expression }
+      SkmBindingBlock.new(:let_star, worker.bindings, body)
+    end
+
     # rule('cond_clause_plus' => 'cond_clause_plus cond_clause').as 'multiple_cond_clauses'
     def reduce_multiple_cond_clauses(_production, _range, _tokens, theChildren)
       theChildren[0] << theChildren[1]
@@ -324,7 +339,7 @@ module Skeem
     def reduce_cond_clause(_production, _range, _tokens, theChildren)
       [theChildren[1], SkmSequencingBlock.new(SkmPair.create_from_a(theChildren[2]))]
     end
-    
+
     # rule('cond_clause' => 'LPAREN test ARROW recipient RPAREN').as 'cond_arrow_clause'
     def reduce_cond_arrow_clause(_production, _range, _tokens, theChildren)
       [theChildren[1], theChildren[3]]
@@ -355,6 +370,31 @@ module Skeem
       SkmBinding.new(theChildren[1], theChildren[2])
     end
 
+    # rule('iteration_spec_star' => 'iteration_spec_star iteration_spec').as 'multiple_iter_specs'
+    def reduce_multiple_iter_specs(_production, _range, _tokens, theChildren)
+      theChildren[0] << theChildren[1]
+    end
+
+    # rule('iteration_spec_star' => []).as 'no_iter_spec_yet'
+    def reduce_no_iter_spec_yet(_production, _range, _tokens, _children)
+      []
+    end
+
+    # rule('iteration_spec' => 'LPAREN IDENTIFIER init step RPAREN').as 'iteration_spec_long'
+    def reduce_iteration_spec_long(_production, _range, _tokens, theChildren)
+      SkmIterationSpec.new(theChildren[1], theChildren[2], theChildren[3])
+    end
+
+    # rule('iteration_spec' => 'LPAREN IDENTIFIER init RPAREN').as 'iteration_spec_short'
+    def reduce_iteration_spec_short(_production, _range, _tokens, theChildren)
+      SkmIterationSpec.new(theChildren[1], theChildren[2], nil)
+    end
+
+    # rule('do_result' => []).as 'empty_do_result'
+    def reduce_empty_do_result(_production, _range, _tokens, theChildren)
+      SkmEmptyList.instance
+    end
+
     # rule('list_qq_template' => 'LPAREN qq_template_or_splice_star RPAREN').as 'list_qq'
     def reduce_list_qq(_production, _range, _tokens, theChildren)
       SkmPair.create_from_a(theChildren[1])

data/lib/skeem/s_expr_nodes.rb

@@ -264,7 +264,7 @@ module Skeem
 
       result
     end
-    
+
     def quasiquote(aRuntime)
         quasi_clauses = clauses.map do |(test, consequent)|
           test_qq = test.quasiquote(aRuntime)
@@ -272,21 +272,21 @@ module Skeem
           [test_qq, consequent_qq]
       end
       quasi_alternate = alternate ? alternate.quasiquote(aRuntime) : nil
-      
+
       self.class.new(position, quasi_clauses, quasi_alternate)
     end
 
     def inspect
       result = inspect_prefix + '@test ' + test.inspect + ', '
-      result << "@clauses \n" 
+      result << "@clauses \n"
       clauses.each do |(test, consequent)|
         result << '  '  << test.inspect << ' ' << consequent.inspect << "\n"
       end
       result << '@alternate ' + alternate.inspect + inspect_suffix
       result
-    end    
+    end
   end # class
-  
+
   SkmArity = Struct.new(:low, :high) do
     def nullary?
       low.zero? && high == 0
@@ -313,6 +313,169 @@ module Skeem
     end
   end
 
+  class SkmIterationSpec
+    attr_reader :variable
+    attr_reader :init_expr
+    attr_reader :step_expr
+
+    def initialize(anIdentifier, anInitialization, aStep)
+      @variable = anIdentifier
+      @init_expr = anInitialization
+      @step_expr = aStep
+    end
+  end # class
+
+class SkmDoExprBuilder
+  attr_reader :bindings
+  attr_reader :update_steps
+  attr_reader :test
+  attr_reader :do_result
+  attr_reader :commands
+
+  # 3 => iteration_spec_star, 6 => test, 7 => do_result, 9 => command_star
+
+  def initialize(iterSpecs, aTest, doResult, theCommands)
+    iteration_specs_set(iterSpecs)
+    @test = aTest
+    @do_result = doResult
+    commands_set(theCommands)
+  end
+
+  def do_expression
+    DoExpression.new(test, do_result, commands, update_steps)
+  end
+
+  private
+
+  def iteration_specs_set(iterSpecs)
+    @bindings = iterSpecs.map do |iter_spec|
+        var = iter_spec.variable
+        val = iter_spec.init_expr
+        SkmBinding.new(var, val)
+      end
+
+    to_update = iterSpecs.select { |iter_spec| iter_spec.step_expr }
+    if to_update
+      steps = to_update.map do |iter_spec|
+        SkmDelayedUpdateBinding.new(iter_spec.variable, iter_spec.step_expr)
+      end
+      if steps.size == 1
+        @update_steps = steps[0]
+      else
+        @update_steps = SkmPair.create_from_a(steps)
+      end
+    else
+      @update_steps = SkmEmptyList.instance
+    end
+  end
+
+  def commands_set(theCommands)
+    case theCommands.size
+      when 0
+        @commands = SkmEmptyList.instance
+      when 1
+        @commands = theCommands[0]
+      else
+        @commands = SkmSequencingBlock.new(SkmPair.create_from_a(theCommands))
+    end
+  end
+end # class
+
+  # Syntax outline:
+  #  LPAREN DO LPAREN iteration_spec_star RPAREN
+  #  LPAREN test do_result RPAREN
+  #  command_star RPAREN
+  # Semantics:
+  #   Initialization:
+  #   Set of variables is initialized (each with its init expression)
+  #   Iteration:
+  #     test expression is evaluation
+  #       if false:
+  #         command expressions are executed in order
+  #         step expressions are executed and bound to the respective variable
+  #         iteration resumes
+  #       if true:
+  #         the do_result expressions are excuted
+  #         value of last expression is returned
+  # ; (do ((vec (make-vector 5))
+  # ; (i 0 (+ i 1)))
+  # ; ((= i 5) vec)
+  # ; (vector-set! vec i i))
+  # Can be transformed into:
+  #  (let* (
+  #    ;; Variable init
+  #    (vec (make-vector 5))
+  #    (i 0)
+  #    ;; Utility procedures
+  #    (update-step (lambda ()
+  #      (begin
+  #        (set! i (+ i 1))
+  #      )))
+  #    (do-results (lambda ()
+  #      (begin
+  #        vec
+  #      )))
+  #    (do-commands (lambda ()
+  #      (begin
+  #        (vector-set! vec i i)
+  #      ))))
+  #    (begin
+  #      (define do-iteration (lambda ()
+  #        (if (= i 5)
+  #          (do-results)
+  #          (begin
+  #            (do-commands)
+  #            (update-step)
+  #            (do-iteration))))))
+  #      (do-iteration))
+  class DoExpression < SkmMultiExpression
+    # iterate until the test expression becomes true
+    attr_reader :test
+
+    # expression to execute in each iteration
+    attr_reader :commands
+
+    # expression to execute before return
+    attr_reader :do_result
+
+    # Update variables
+    attr_reader :update_steps
+
+    def initialize(aTest, doResult, theCommands, theUpdates)
+      @test = aTest
+      @do_result = doResult
+      @commands = theCommands
+      @update_steps = theUpdates
+    end
+
+    def evaluate(aRuntime)
+      # require 'debug'
+      loop do
+        test_result = test.evaluate(aRuntime)
+        if test_result.boolean? && test_result.value == false
+          # Only #f is considered as false, everything else is true
+          commands.evaluate(aRuntime) if commands
+          if update_steps
+            update_steps.evaluate(aRuntime)
+            case update_steps
+              when SkmEmptyList.instance
+                ; Do nothing
+              when SkmPair
+                arr = update_steps.to_a
+                arr.each { |delayed_binding| delayed_binding.do_it!(aRuntime) }
+              else
+                update_steps.do_it!(aRuntime)
+            end
+          end
+        else
+          break
+        end
+      end
+
+      do_result ? do_result.evaluate(aRuntime) : SkmUndefined.instance
+    end
+  end # class
+
   class SkmFormals
     attr_reader :formals
     attr_reader :arity
@@ -384,7 +547,7 @@ module Skeem
     def callable?
       true
     end
-    
+
     def procedure?
       true
     end
@@ -540,10 +703,10 @@ require_relative 'skm_procedure_exec'
     def callable?
       true
     end
-    
+
     def procedure?
       true
-    end    
+    end
 =begin
   TODO
     def quasiquote(aRuntime)

data/lib/skeem/skm_binding.rb

@@ -1,17 +1,17 @@
 require_relative 'skm_element'
 
 module Skeem
-  
+
   # An identifier that is not a syntactic keyword can be used as a variable.
   # A variable may give a name to value that is bound (i.e. associated)
   # to that variable.
   class SkmBinding < SkmElement
     # @return [SkmIdentifier] The identifier that is bound the value.
     attr_reader(:variable)
-    
+
     # @return [SkmElement] The Skeem object that is associated with the variable.
     attr_reader(:value)
-    
+
     # Constructor
     # @param anIdentifier [SkmIdentifier] The variable name
     # @param aValue [SkmElement] The value to bind to the variable.
@@ -19,7 +19,7 @@ module Skeem
       @variable = anIdentifier
       @value = aValue
     end
-    
+
     def evaluate(aRuntime)
       name = variable.evaluate(aRuntime)
 
@@ -38,44 +38,12 @@ module Skeem
       else
         result = value.evaluate(aRuntime)
       end
-      
-=begin      
-      aRuntime.add_binding(var_key, self)
-      case expression
-        when SkmLambda
-          result = expression.evaluate(aRuntime)
-
-        when SkmVariableReference
-          other_key = expression.variable.evaluate(aRuntime)
-          if var_key.value != other_key.value
-            entry = aRuntime.fetch(other_key)
-            result = expression.evaluate(aRuntime)
-            if entry.kind_of?(Primitive::PrimitiveProcedure)
-              @expression = entry
-            elsif entry.kind_of?(SkmDefinition)
-              if entry.expression.kind_of?(SkmLambda)
-                @expression = entry.expression
-              end
-            end
-          else
-            # INFINITE LOOP DANGER: definition of 'x' has a reference to 'x'!
-            # Way out: the lookup for the reference should start from outer
-            # environment.
-            env = aRuntime.pop
-            @expression = expression.evaluate(aRuntime)
-            aRuntime.push(env)
-            result = expression
-          end
-        else
-          result = self
-      end
-=end
       binding_action(aRuntime, name, result)
       result
     end
-    
+
     protected
-    
+
     def binding_action(aRuntime, anIdentifier, anExpression)
       aRuntime.add_binding(anIdentifier, anExpression)
     end
@@ -87,17 +55,35 @@ module Skeem
       end
 
       result
-    end    
-    
+    end
+
   end # class
-  
+
 
   class SkmUpdateBinding < SkmBinding
-  
+
     protected
-    
+
     def binding_action(aRuntime, anIdentifier, anExpression)
       aRuntime.update_binding(anIdentifier, anExpression)
-    end    
+    end
   end # class
+  
+  class SkmDelayedUpdateBinding < SkmBinding
+    attr_reader :new_val
+    
+    def initialize(anIdentifier, aValue)
+      super(anIdentifier, aValue)
+    end
+    
+    def do_it!(aRuntime)
+      aRuntime.update_binding(variable, new_val)
+    end
+
+    protected
+
+    def binding_action(_runtime, _identifier, anExpression)
+      @new_val = anExpression
+    end
+  end # class  
 end # module

data/lib/skeem/skm_unary_expression.rb

@@ -111,7 +111,7 @@ module Skeem
     end
   end # class
 
-  # Used to represent local binding constructs (let, let*, letrec, letrec*)
+  # Used to represent local binding constructs (let, let\*, letrec, letrec\*)
   class SkmBindingBlock < SkmUnaryExpression
     alias body child
 

data/lib/skeem/tokenizer.rb

@@ -35,6 +35,7 @@ module Skeem
       BEGIN
       COND
       DEFINE
+      DO
       ELSE
       IF
       LAMBDA

data/lib/skeem/version.rb

@@ -1,3 +1,3 @@
 module Skeem
-  VERSION = '0.2.13'.freeze
+  VERSION = '0.2.14'.freeze
 end

data/spec/skeem/interpreter_spec.rb

@@ -718,7 +718,7 @@ SKEEM
           ["(not 'nil)", false]
         ]
         compare_to_predicted(checks)
-      end      
+      end
 
       it 'should implement the list procedure' do
         checks = [
@@ -874,5 +874,28 @@ SKEEM
         expect(result.last).to eq(80)
       end
     end # context
+
+    context 'Derived expressions' do
+      it 'should implement the do form' do
+        source = <<-SKEEM
+          (do ((vec (make-vector 5))
+                (i 0 (+ i 1)))
+              ((= i 5) vec)
+            (vector-set! vec i i)) ; => #(0 1 2 3 4)
+SKEEM
+        result = subject.run(source)
+        expect(result).to eq([0, 1, 2, 3, 4])
+        
+        source = <<-SKEEM
+          (let ((x '(1 3 5 7 9)))
+            (do (
+              (x x (cdr x))
+              (sum 0 (+ sum (car x))))
+              ((null? x) sum))) ; => 25
+SKEEM
+        result = subject.run(source)
+        expect(result).to eq(25)        
+      end
+    end # context
   end # describe
 end # module

data/spec/skeem/primitive/primitive_builder_spec.rb

@@ -13,6 +13,10 @@ module Skeem
         Interpreter.new { |interp| interp.add_primitives(interp.runtime) }
       end
 
+      def array2list_ids(arr)
+        arr.map { |elem| SkmIdentifier.create(elem) }
+      end
+
       context 'Arithmetic operators:' do
         it 'should implement the set! form' do
           skeem1 = <<-SKEEM
@@ -631,10 +635,6 @@ SKEEM
           compare_to_predicted(checks)
         end
 
-        def array2list_ids(arr)
-          arr.map { |elem| SkmIdentifier.create(elem) }
-        end
-
         it 'should implement the append procedure' do
           checks = [
             ["(append '(a b c) '())", array2list_ids(['a', 'b', 'c'])],
@@ -898,6 +898,32 @@ SKEEM
           expect(result).to eq(8)
         end
 
+        it 'should implement the vector-set! procedure' do
+          source =<<-SKEEM
+  (let
+    ((vec (vector 0 '(2 2 2 2) "Anna")))
+    (vector-set! vec 1 '("Sue" "Sue"))
+  vec)
+SKEEM
+#(0 ("Sue" "Sue") "Anna")
+          result = subject.run(source)
+          expect(result).to be_kind_of(SkmVector)
+          expectation = [SkmInteger.create(0), 
+            SkmPair.new(SkmString.create("Sue"), SkmPair.new(SkmString.create("Sue"), SkmEmptyList.instance)),
+            SkmString.create("Anna") ]
+          expect(result).to eq(expectation)
+
+          source =<<-SKEEM
+  (let (
+    (v (vector 'a 'b 'c 'd 'e)))
+    (vector-set! v 2 'x)
+    v)
+SKEEM
+          result = subject.run(source)
+          expect(result).to be_kind_of(SkmVector)
+          expect(result).to eq(array2list_ids(['a', 'b', 'x', 'd', 'e']))
+        end
+
         it 'should implement the vector->list procedure' do
           checks = [
             ["(vector->list #())", []],

metadata

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