skeem 0.0.11 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a42694aa5f20550be636b493bcf451db3b5d70f8
-  data.tar.gz: a3f65ef0a724758a257fbaaf5570edf8c341ea08
+  metadata.gz: d588cbeb0a65a6d0821ca4298fb15f577b873a0f
+  data.tar.gz: b71fd66e1970299cef3e5802be3a8800cef3dd83
 SHA512:
-  metadata.gz: afa3959e8f8e9873b08cc242954350dbf61ab0cb2296ce46175f68e70070498cc10446031b32011536e39b8f7cb9a2f7bd1977e949c98a7b541b61aae2310674
-  data.tar.gz: 6c07561060a42c776a14534fa117734850c3878d83c915bda6c997eab1e29cf88417d35bdaa9fa0e0071ad7c3ac5aef38759ee7e0855aeaf2e774cd6fa810959
+  metadata.gz: e2aa7dec8f113fe704d859201f4176d7dcea1870a02d2fd7d6c89e96b1e2f3848d3e99c6283f95326a40a54af7c153834d8a213d6dcf8b3afd772bfbf2d28989
+  data.tar.gz: 3f46e06c1c4b603b3b0af8d49bfd2180ffd4aba3906492ae845dc2e0d2c727286f8e63e09d9e8aeb1ca5dae7f6e47635f7364022e688d713086ec7ed63e2428f

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## [0.0.12] - 2018-09-17
+Added primitive `define` and variable reference
+
+### Added
+- Class `SkmDefinition` for representing a specific definition.
+- Class `SkmVariableReference` for representing a variable reference (i.e. retrieving its value)
+- Module `Convertible` implementing utility methods for converting "native" Ruby objects into their Skeem counterpart.
+- Class `SkmBuilder`. Added methods to implement the semantic actions for `define` and variable reference.
+- File `interpreter_spec.rb` added tests for `define` and variable reference.
+
+### Changed
+- File `README.md` Changed demo snippet with example of variable definition and variable reference.
+
 ## [0.0.11] - 2018-09-16
 Added primitive procedures: `=`, `<`, `>`, `>=`, `<=`
 

data/README.md

@@ -32,11 +32,14 @@ At this stage, the gem consists of a bare-bones interpreter.
 
   schemer = Skeem::Interpreter.new
   scheme_code =<<-SKEEM
-    ; Let's try some arithmetic expression
-    (+ (* 2 100) (* 1 10))
+    ; Let's define a Scheme variable
+    (define foobar (* 2 3 7))
+
+    ; Now retrieve its value
+    foobar
   SKEEM
   result = schemer.run(scheme_code)
-  puts result.value # => 210
+  puts result.value # => 42
 ```
 
 Roadmap:

data/lib/skeem/convertible.rb

@@ -0,0 +1,17 @@
+require_relative 's_expr_nodes'
+
+module Skeem
+  module Convertible
+    # Convert Ruby object into its Skeem counterpart
+    def to_skm(native_obj)
+      case native_obj
+        when TrueClass, FalseClass
+          SkmBoolean.create(native_obj)
+        when Float
+          SkmReal.create(native_obj)
+        when Integer
+          SkmInteger.create(native_obj)
+      end
+    end
+  end # module
+end # module

data/lib/skeem/grammar.rb

@@ -21,14 +21,14 @@ module Skeem
     # add_terminals('BEGIN', 'DEFINE')
     add_terminals('DEFINE')
     
-    rule 'program' => 'cmd_or_def_plus'
-    rule 'cmd_or_def_plus' => 'cmd_or_def_plus cmd_or_def'
-    rule 'cmd_or_def_plus' => 'cmd_or_def'
+    rule('program' => 'cmd_or_def_plus').as 'main'
+    rule('cmd_or_def_plus' => 'cmd_or_def_plus cmd_or_def').as 'multiple_cmd_def'
+    rule('cmd_or_def_plus' => 'cmd_or_def').as 'last_cmd_def'
     rule 'cmd_or_def' => 'command'
     rule 'cmd_or_def' => 'definition'
     rule 'command' => 'expression'
-    rule 'definition' => 'LPAREN DEFINE IDENTIFIER expression RPAREN'
-    rule 'expression' =>  'IDENTIFIER'
+    rule('definition' => 'LPAREN DEFINE IDENTIFIER expression RPAREN').as 'definition'
+    rule('expression' =>  'IDENTIFIER').as 'variable_reference'
     rule 'expression' =>  'literal'
     rule 'expression' =>  'procedure_call'
     rule 'literal' => 'self-evaluating'

data/lib/skeem/primitive/primitive_builder.rb

@@ -1,8 +1,10 @@
 require_relative '../primitive_procedure'
+require_relative '../convertible'
 
 module Skeem
   module Primitive
     module PrimitiveBuilder
+      include Convertible
       def add_primitives(aRuntime)
         add_arithmetic(aRuntime)
         add_comparison(aRuntime)
@@ -238,18 +240,6 @@ module Skeem
       def define(aRuntime, aKey, anEntry)
         aRuntime.define(aKey, anEntry)
       end
-
-      # Convert Ruby object into its Skeem counterpart
-      def to_skm(native_obj)
-        case native_obj
-          when TrueClass, FalseClass
-            SkmBoolean.create(native_obj)
-          when Float
-            SkmReal.create(native_obj)
-          when Integer
-            SkmInteger.create(native_obj)
-        end
-      end
     end # module
   end # module
 end # module

data/lib/skeem/s_expr_builder.rb

@@ -35,6 +35,38 @@ module Skeem
       Terminal2NodeClass
     end
 
+    # rule('program' => 'cmd_or_def_plus').as 'main'
+    def reduce_main(_production, _range, _tokens, theChildren)
+      last_child = theChildren.last
+      result = if last_child.members.size == 1
+                  last_child.members[0]
+                else
+                  last_child
+                end
+    end
+
+    # rule('cmd_or_def_plus' => 'cmd_or_def_plus cmd_or_def').as 'multiple_cmd_def'
+    def reduce_multiple_cmd_def(_production, _range, _tokens, theChildren)
+      theChildren[0].members << theChildren[1]
+      theChildren[0]
+    end
+
+    # rule('cmd_or_def_plus' => 'cmd_or_def').as 'last_cmd_def'
+    def reduce_last_cmd_def(_production, _range, _tokens, theChildren)
+      SkmList.new([theChildren.last])
+    end
+
+    # rule('definition' => 'LPAREN DEFINE IDENTIFIER expression RPAREN')
+    #  .as 'definition'
+    def reduce_definition(_production, aRange, _tokens, theChildren)
+      SkmDefinition.new(aRange, theChildren[2], theChildren[3])
+    end
+
+    # rule('expression' =>  'IDENTIFIER').as 'variable_reference'
+    def reduce_variable_reference(_production, aRange, _tokens, theChildren)
+      SkmVariableReference.new(aRange, theChildren[0])
+    end
+
     # rule('proc_call_args' => 'LPAREN operator operand_plus RPAREN')
     def reduce_proc_call_args(_production, aRange, _tokens, theChildren)
       ProcedureCall.new(aRange, theChildren[1], theChildren[2])

data/lib/skeem/s_expr_nodes.rb

@@ -199,25 +199,74 @@ module Skeem
     alias subnodes members
   end # class
 
+  class SkmDefinition < SkmElement
+    attr_reader :variable
+    attr_reader :expression
+
+    def initialize(aPosition, aVariable, theExpression)
+      super(aPosition)
+      @variable = aVariable
+      @expression = theExpression
+    end
+
+    def evaluate(aRuntime)
+      var_key = variable.evaluate(aRuntime)
+      aRuntime.define(var_key, self)
+      self
+    end
+  end # class
+  
+  class SkmVariableReference  < SkmElement
+    attr_reader :variable
+    
+    def initialize(aPosition, aVariable)
+      super(aPosition)
+      @variable = aVariable
+    end
+
+    def evaluate(aRuntime)
+      var_key = variable.evaluate(aRuntime)
+      unless aRuntime.include?(var_key.value)
+        err = StandardError
+        key = var_key.kind_of?(SkmIdentifier) ? var_key.value : var_key
+        err_msg = "Unknown variable '#{key}'"
+        raise err, err_msg
+      end
+      definition = aRuntime.environment.bindings[var_key.value]
+      result = definition.expression.evaluate(aRuntime)
+    end
+
+    # Confusing!
+    # Value, here, means the value of the identifier (the variable's name).
+    def value()
+      variable.value
+    end
+  end
+
   class ProcedureCall < SkmElement
     attr_reader :operator
     attr_reader :operands
 
     def initialize(aPosition, anOperator, theOperands)
       super(aPosition)
-      @operator = anOperator
+      if anOperator.kind_of?(SkmVariableReference)
+        # Kinky: variable names are procedure names, not variable reference
+        @operator = SkmIdentifier.create(anOperator.value)
+      else
+        @operator = anOperator
+      end
       @operands = SkmList.new(theOperands)
     end
 
     def evaluate(aRuntime)
-      proc_key = operator.evaluate(aRuntime)
-      unless aRuntime.include?(proc_key.value)
+      var_key = operator.evaluate(aRuntime)
+      unless aRuntime.include?(var_key.value)
         err = StandardError
-        key = proc_key.kind_of?(SkmIdentifier) ? proc_key.value : proc_key
-        err_msg = "Unknown function '#{key}'"
+        key = var_key.kind_of?(SkmIdentifier) ? var_key.value : var_key
+        err_msg = "Unknown procedure '#{key}'"
         raise err, err_msg
       end
-      procedure = aRuntime.environment.bindings[proc_key.value]
+      procedure = aRuntime.environment.bindings[var_key.value]
       result = procedure.call(aRuntime, self)
     end
 

data/lib/skeem/version.rb

@@ -1,3 +1,3 @@
 module Skeem
-  VERSION = '0.0.11'.freeze
+  VERSION = '0.0.12'.freeze
 end

data/spec/skeem/interpreter_spec.rb

@@ -76,18 +76,24 @@ module Skeem
           expect(result.value).to eq(predicted)
         end
       end
-
-      it 'should evaluate isolated identifiers' do
-        samples = [
-          ['the-word-recursion-has-many-meanings',
-          'the-word-recursion-has-many-meanings']
-        ]
-        samples.each do |source, predicted|
-          result = subject.run(source)
-          expect(result).to be_kind_of(SkmIdentifier)
-          expect(result.value).to eq(predicted)
-        end
+    end # context
+   
+    context 'Built-in primitives' do      
+      it 'should implement variable definition' do
+        result = subject.run('(define x 28)')
+        expect(result).to be_kind_of(SkmDefinition)
       end
+      
+      it 'should implement variable reference' do
+        source = <<-SKEEM
+  ; Example from R7RS section 4.1.1
+  (define x 28)
+  x
+SKEEM
+        result = subject.run(source)
+        expect(result).to be_kind_of(SkmInteger)
+        expect(result.value).to eq(28)
+      end      
     end # context
 
     context 'Built-in primitive procedures' do
@@ -120,9 +126,14 @@ module Skeem
       end
 
       it 'should implement the product of numbers' do
-        result = subject.run('(* 2 3 4)')
-        expect(result).to be_kind_of(SkmInteger)
-        expect(result.value).to eq(24)
+        checks = [
+          ['(* 5 8)', 40],
+          ['(* 2 3 4)', 24]
+        ]
+        checks.each do |(skeem_expr, expectation)|
+          result = subject.run(skeem_expr)
+          expect(result.value).to eq(expectation)
+        end
       end
 
       it 'should implement the division of numbers' do

data/spec/skeem/parser_spec.rb

@@ -75,7 +75,7 @@ module Skeem
       ]
         samples.each do |source, predicted|
           ptree = subject.parse(source)
-          expect(ptree.root).to be_kind_of(SkmIdentifier)
+          expect(ptree.root).to be_kind_of(SkmVariableReference)
           expect(ptree.root.value).to eq(predicted)
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skeem
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-16 00:00:00.000000000 Z
+date: 2018-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -85,6 +85,7 @@ files:
 - Rakefile
 - appveyor.yml
 - lib/skeem.rb
+- lib/skeem/convertible.rb
 - lib/skeem/environment.rb
 - lib/skeem/grammar.rb
 - lib/skeem/interpreter.rb