skeem 0.0.24 → 0.0.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e1f6bf0ae4407a85eb404c02c2497964744c26b2
-  data.tar.gz: f66450bf98cb129a7e40499bf589ef6454760c12
+  metadata.gz: bb979d01736d3b23101b56c2b7c21dff003eed46
+  data.tar.gz: 91dddadb24f3e6cc1aa146f7c5420d4d88708d56
 SHA512:
-  metadata.gz: f07d638db941e45c54717ba99addfdb627ba9c76ace292905bb3fa3687888a42a633f51cc9dc6975d058f6995782e56f9a7439cc8e0a0086c1a4ba93be84040a
-  data.tar.gz: 03b924927a3cf1e08780de16743403ab17ca68646e17f1f1b36bcfc58f3478cf403d09c2cf0626306f83dc60e6b06c4a9df57502500ca246361bbcc641833bc7
+  metadata.gz: 1a3db261dbca2bf57909b90de1db6897026eea3baa739e80a52c2ee045eee1be23d685d903757ed1fb1ca92daac80cbbcdc9fb015d7f6daeb7d275262f5952fe
+  data.tar.gz: 27f38b7d92bbe22f339de58945fd7dad7efc9b57ffc1257f626fd3d97b5bd063c3432eb124e28e75d67ff35f7bf75470af15ea8ddb633850d4b21b76e122012f

data/README.md

@@ -129,6 +129,7 @@ Here are a few pointers for the Scheme programming language:
 - Lambda expressions
 - If conditionals
 - Definitions
+- Assignments
 
 ### Standard syntactic forms
 #### define  
@@ -155,6 +156,13 @@ __Syntax:__
 * (quote <datum\>)
 * '<datum\>
 
+#### set!  
+__Purpose:__ Assign to an existing variable an expression/value to it.  
+__Syntax:__   
+* (set! <identifier\> <expression\>)  
+
+
+
 ### Standard library
 This section lists the implemented standard procedures
 
@@ -170,10 +178,10 @@ This section lists the implemented standard procedures
 * `list?`, `null?`, `list`, `length`
 
 #### String procedures
-* `string?`, `string-append`, `string-length`, `string->symbol`,
+* `string?`, `string=?`,  `string-append`, `string-length`, `string->symbol`,
 
 #### Symbol procedures
-* `symbol?`
+* `symbol?`, `symbol=?`
 
 #### Vector procedures
 * `vector?`, `vector`, `vector-length`, `vector-set!`

data/lib/skeem/primitive/primitive_builder.rb

@@ -1,11 +1,13 @@
 require_relative 'primitive_procedure'
 require_relative '../datum_dsl'
+# require_relative '../s_expr_nodes'
 
 module Skeem
   module Primitive
     module PrimitiveBuilder
       include DatumDSL
       def add_primitives(aRuntime)
+        add_binding(aRuntime)
         add_arithmetic(aRuntime)
         add_comparison(aRuntime)
         add_number_procedures(aRuntime)
@@ -40,6 +42,10 @@ module Skeem
         SkmArity.new(1, '*')
       end
 
+      def add_binding(aRuntime)
+        create_set!(aRuntime)
+      end
+
       def add_arithmetic(aRuntime)
         create_plus(aRuntime)
         create_minus(aRuntime)
@@ -72,6 +78,7 @@ module Skeem
 
       def add_string_procedures(aRuntime)
         create_object_predicate(aRuntime, 'string?')
+        create_string_equal(aRuntime)
         create_string_append(aRuntime)
         create_string_length(aRuntime)
         create_string2symbol(aRuntime)
@@ -102,6 +109,19 @@ module Skeem
         create_debug(aRuntime)
       end
 
+      def create_set!(aRuntime)
+          primitive = ->(runtime, var_ref, expr) do
+            if runtime.include?(var_ref.child)
+              redefinition = SkmDefinition.new(nil, var_ref.child, expr)
+              redefinition.evaluate(runtime)
+            else
+              raise StandardError, "Unbound variable: '#{var.value}'"
+            end
+        end
+
+        define_primitive_proc(aRuntime, 'set!', binary, primitive)
+      end
+
       def create_plus(aRuntime)
         # arglist should be a Ruby Array
         primitive = ->(runtime, arglist) do
@@ -338,6 +358,22 @@ module Skeem
         define_primitive_proc(aRuntime, 'or', zero_or_more, primitive)
       end
 
+      def create_string_equal(aRuntime)
+        primitive = ->(runtime, first_operand, arglist) do
+          first_one = first_operand.evaluate(runtime)
+          if arglist.empty?
+            boolean(true)
+          else
+            operands = evaluate_array(arglist, runtime)
+            first_value = first_one.value
+            all_equal = operands.all? { |elem| first_value == elem.value }
+            boolean(all_equal)
+          end
+        end
+
+        define_primitive_proc(aRuntime, 'string=?', one_or_more, primitive)
+      end
+
       def create_string_append(aRuntime)
         primitive = ->(runtime, arglist) do
           if arglist.empty?

data/lib/skeem/runtime.rb

@@ -12,6 +12,11 @@ module Skeem
     def include?(anIdentifier)
       environment.include?(normalize_key(anIdentifier))
     end
+    
+    def fetch(aKey)
+      key_value = normalize_key(aKey)
+      include?(key_value) ? environment.fetch(key_value) : nil
+    end
 
     def define(aKey, anEntry)
       environment.define(normalize_key(aKey), anEntry)
@@ -20,8 +25,15 @@ module Skeem
     def evaluate(aKey)
       key_value = normalize_key(aKey)
       if include?(key_value)
-        definition = environment.fetch(key_value)
-        definition.expression.evaluate(self)
+        entry = environment.fetch(key_value)
+        case entry
+          when Primitive::PrimitiveProcedure
+            entry
+          when SkmDefinition
+            entry.expression.evaluate(self)
+          else
+            raise StandardError, entry.inspect
+        end
       else
         err = StandardError
         key = aKey.kind_of?(SkmIdentifier) ? aKey.value : key_value

data/lib/skeem/s_expr_nodes.rb

@@ -58,8 +58,16 @@ module Skeem
         when SkmVariableReference
           other_key = expression.variable.evaluate(aRuntime)
           if var_key.value != other_key.value
+            entry = aRuntime.fetch(other_key)
             result = expression.evaluate(aRuntime)
-           else
+            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' is a reference to 'x'!
             # Way out: the lookup for the reference should start from outer
             # environment.
@@ -88,7 +96,7 @@ module Skeem
 
     # call method should only invoked when the expression is a SkmLambda
     def call(aRuntime, aProcedureCall)
-      unless expression.kind_of?(SkmLambda)
+      unless [SkmLambda, Primitive::PrimitiveProcedure].include?(expression.class) 
         err_msg = "Expected a SkmLambda instead of #{expression.class}"
         raise StandardError, err_msg
       end

data/lib/skeem/standard/base.skm

@@ -45,5 +45,7 @@
   (lambda (z)
     (* z z)))
 
+(define symbol=? string=?)
+    
 (define list
   (lambda args args))

data/lib/skeem/version.rb

@@ -1,3 +1,3 @@
 module Skeem
-  VERSION = '0.0.24'.freeze
+  VERSION = '0.0.25'.freeze
 end

data/spec/skeem/interpreter_spec.rb

@@ -1,9 +1,12 @@
 require 'stringio'
 require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/skeem/datum_dsl'
 require_relative '../../lib/skeem/interpreter' # Load the class under test
 
 module Skeem
   describe Interpreter do
+    include DatumDSL
+
     context 'Initialization:' do
       it 'should be initialized without argument' do
         expect { Interpreter.new() }.not_to raise_error
@@ -329,6 +332,41 @@ SKEEM
           expect(result.members[index]).to eq(value)
         end
       end
+      
+      it 'should implement the unquote of vectors' do
+        source = '`#( ,(+ 1 2) 4)'
+        result = subject.run(source)
+        expect(result).to be_kind_of(SkmVector)
+        predictions = [
+          [SkmInteger, 3],
+          [SkmInteger, 4]
+        ]
+        predictions.each_with_index do |(type, value), index|
+          expect(result.members[index]).to be_kind_of(type)
+          expect(result.members[index]).to eq(value)
+        end
+
+        source = "`#()"
+        result = subject.run(source)
+        expect(result).to be_kind_of(SkmVector)
+        expect(result).to be_empty
+        
+        # Nested vectors
+        source = '`#(a b #(,(+ 2 3) c) d)'
+        result = subject.run(source)
+        # expected: #(a b #(5 c) d)
+        expect(result).to be_kind_of(SkmVector)
+        predictions = [
+          [SkmIdentifier, 'a'],
+          [SkmIdentifier, 'b'],
+          [SkmVector, vector([integer(5), identifier('c')])],
+          [SkmIdentifier, 'd']
+        ]
+        predictions.each_with_index do |(type, value), index|
+          expect(result.members[index]).to be_kind_of(type)
+          expect(result.members[index]).to eq(value)
+        end        
+      end      
             
       it 'should implement the quasiquotation of lists' do
         source = '(quasiquote (+ 1 2))'
@@ -368,10 +406,25 @@ SKEEM
         result = subject.run(source)
         expect(result).to be_kind_of(SkmList)
         expect(result).to be_null
+        
+        # nested lists
+        source = '`(a b (,(+ 2 3) c) d)'
+        result = subject.run(source)
+        # expected: (a b (5 c) d)
+        expect(result).to be_kind_of(SkmList)
+        predictions = [
+          [SkmIdentifier, 'a'],
+          [SkmIdentifier, 'b'],
+          [SkmList, list([integer(5), identifier('c')])],
+          [SkmIdentifier, 'd']
+        ]
+        predictions.each_with_index do |(type, value), index|
+          expect(result.members[index]).to be_kind_of(type)
+          expect(result.members[index]).to eq(value)
+        end        
       end
 =begin
 `(+ 2 ,(* 3 4))  (+ 2 12)
-`(a b (,(+ 2 3) c) d)  (a b (5 c) d)
 `(a b ,(reverse '(c d e)) f g)  (a b (e d c) f g)
 (let ([a 1] [b 2])
   `(,a . ,b))  (1 . 2) 
@@ -514,6 +567,18 @@ SKEEM
           expect(result).to eq(expectation)
         end
       end
+      
+      it 'should implement the symbol=? procedure' do
+        checks = [
+          ["(symbol=? 'a 'a)", true],
+          ["(symbol=? 'a (string->symbol \"a\"))", true],
+          ["(symbol=? 'a 'b)", false]
+        ]
+        checks.each do |(skeem_expr, expectation)|
+          result = subject.run(skeem_expr)
+          expect(result).to eq(expectation)
+        end
+      end       
 
       it 'should implement the list procedure' do
         checks = [

data/spec/skeem/primitive/primitive_builder_spec.rb

@@ -6,8 +6,26 @@ require_relative '../../../lib/skeem/interpreter'
 module Skeem
   module Primitive
     describe 'Testing primitive procedures' do
-        subject { Interpreter.new }
-        context 'Arithmetic operators:' do
+      subject { Interpreter.new }
+      
+      context 'Arithmetic operators:' do
+        it 'should implement the set! form' do
+          skeem1 = <<-SKEEM
+  (define x 2)
+  (+ x 1)
+SKEEM
+          result = subject.run(skeem1)
+          expect(result.last).to eq(3)  # x is bound to value 2
+          skeem2 = <<-SKEEM
+  (set! x 4)
+  (+ x 1)
+SKEEM
+          result = subject.run(skeem2)
+          expect(result.last).to eq(5)  # x is now bound to value 4
+        end        
+      end # context
+
+      context 'Arithmetic operators:' do
         it 'should implement the addition operator' do
           [
             ['(+)', 0], # '+' as nullary operator. Example from section 6.2.6
@@ -294,6 +312,18 @@ module Skeem
           end
         end
 
+        it 'should implement the string=? procedure' do
+          checks = [
+            ['(string=? "Mom" "Mom")', true],
+            ['(string=? "Mom" "Mum")', false],
+            ['(string=? "Mom" "Dad")', false]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result).to eq(expectation)
+          end
+        end
+
         it 'should implement the string-append procedure' do
           checks = [
             ['(string-append)', ''],
@@ -323,22 +353,24 @@ module Skeem
         it 'should implement the symbol? procedure' do
           checks = [
             ['(symbol? #f)', false],
-            ['(symbol? "bar")', false]
+            ['(symbol? "bar")', false],
+            ["(symbol? '())", false],
+            ["(symbol? 'foo)", true],
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
             expect(result).to eq(expectation)
           end
-        end
+        end       
       end # context
 
       context 'List procedures:' do
         it 'should implement the list? procedure' do
           checks = [
-            #['(list? #f)', false],
-            #['(list? 1)', false],
-            #['(list? "bar")', false],
-            #['(list? (list 1 2 3))', true],
+            ['(list? #f)', false],
+            ['(list? 1)', false],
+            ['(list? "bar")', false],
+            ['(list? (list 1 2 3))', true],
             ['(list? (list))', true]
           ]
           checks.each do |(skeem_expr, expectation)|

data/spec/skeem/runtime_spec.rb

@@ -39,14 +39,14 @@ module Skeem
     context 'Evaluation:' do
       include Primitive::PrimitiveBuilder
       
-      it 'should evaluate a given entry' do
-        entry = double('three')
-        result = double('fake-procedure')
-        expect(entry).to receive(:expression).and_return(result)
-        expect(result).to receive(:evaluate).with(subject).and_return(integer(3))
-        subject.define('three', entry)
-        expect(subject.evaluate('three')).to eq(3)
-      end
+      # it 'should evaluate a given entry' do
+        # entry = integer(3)
+        # result = double('fake-procedure')
+        # expect(entry).to receive(:expression).and_return(result)
+        # expect(result).to receive(:evaluate).with(subject).and_return(integer(3))
+        # subject.define('three', entry)
+        # expect(subject.evaluate('three')).to eq(3)
+      # end
       
       it 'should evaluate a given list' do
         add_primitives(subject)

data/spec/skeem/s_expr_nodes_spec.rb

@@ -1,6 +1,7 @@
 require 'ostruct'
 require_relative '../spec_helper' # Use the RSpec framework
 require_relative '../../lib/skeem/runtime'
+require_relative '../../lib/skeem/primitive/primitive_builder'
 require_relative '../../lib/skeem/s_expr_nodes' # Load the classes under test
 
 module Skeem
@@ -26,6 +27,8 @@ module Skeem
     end # context
 
     context 'Provided services:' do
+      include Primitive::PrimitiveBuilder
+      
       let(:runtime) { Runtime.new(Environment.new) }
 
       it 'should create an entry when evaluating' do
@@ -34,6 +37,39 @@ module Skeem
         expect(runtime).to include(sample_symbol)
       end
       
+      it 'should optimize an entry that aliases a primitive proc' do
+        add_primitives(runtime)
+        identifier = SkmIdentifier.create('plus')
+        proc_name = SkmIdentifier.create('+')
+        var_ref = SkmVariableReference.new(nil, proc_name)
+        instance = SkmDefinition.new(nil, identifier, var_ref) # (define plus +)
+        expect(instance.expression).to eq(var_ref)
+        instance.evaluate(runtime)
+        # Optimization by getting rid of indirection
+        expect(instance.expression).to be_kind_of(Primitive::PrimitiveProcedure)
+      end
+
+      it 'should optimize an entry that aliases a lambda proc' do
+        # Let's define a (dummy) lambda
+        formals = SkmFormals.new([], :fixed)
+        dummy_body = { :defs => [], :sequence => [SkmInteger.create(3)]}
+        lbd = SkmLambda.new(nil, formals, dummy_body)
+        id = SkmIdentifier.create('some-lambda')
+        def1 = SkmDefinition.new(nil, id, lbd)
+        def1.evaluate(runtime)
+      
+        # Let's create an alias to the lambda
+        other_name = SkmIdentifier.create('aliased-lambda')
+        var_ref = SkmVariableReference.new(nil, id)
+        
+        # (define aliased-lambda some-lambda)
+        def2 = SkmDefinition.new(nil, other_name, var_ref) 
+        expect(def2.expression).to eq(var_ref)
+        def2.evaluate(runtime)
+        # Optimization by getting rid of indirection
+        expect(def2.expression).to eq(lbd)
+      end       
+      
       it 'should quasiquote its variable and expression' do
         alter_ego = subject.quasiquote(runtime)
         expect(alter_ego).to eq(subject)        

data/spec/skeem/skm_unary_expression_spec.rb

@@ -1,6 +1,7 @@
 require_relative '../spec_helper' # Use the RSpec framework
 require_relative '../../lib/skeem/datum_dsl'
 require_relative '../../lib/skeem/environment'
+require_relative '../../lib/skeem/s_expr_nodes'
 require_relative '../../lib/skeem/skm_unary_expression' # Load the classes under test
 
 module Skeem
@@ -176,15 +177,14 @@ module Skeem
     end # context
 
     context 'Provided services:' do
-      let(:dummy_def) { double('fake-definition') }
+      let(:sample_def) { SkmDefinition.new(nil, identifier('three'), integer(3)) }
       let(:runtime) { Runtime.new(Environment.new) }
 
       before(:each) do
-        runtime.define('three', dummy_def)
+        runtime.define('three', sample_def)
       end
 
       it "should return the variable's value at evaluation" do
-        expect(dummy_def).to receive(:expression).and_return(integer(3))
         expect(subject.evaluate(runtime)).to eq(3)
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skeem
 version: !ruby/object:Gem::Version
-  version: 0.0.24
+  version: 0.0.25
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-08 00:00:00.000000000 Z
+date: 2018-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley