skeem 0.0.13 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ba107706c9483fb97e9a628b621ca7932c00f16d
-  data.tar.gz: 14ddf9ec1cebab58ae123ffbef3786f306824cb3
+  metadata.gz: 4738bc3d483df0325cce143200b02e5c8cac7afe
+  data.tar.gz: 8f4560eaa88c6e754bd423bdf3c1f62a35063b75
 SHA512:
-  metadata.gz: bfb3e078734b6e7ed68161f095c5c5c3287afd8c4fd1583b7a0e7f1d79c112aead08dd4e95d804ee68d7bfc7c1da73841252ef8eb8acdf88700d929682a2dc35
-  data.tar.gz: 5fd3ed354914cb9af65fd0e7836d3a474c45f980fcbf4a0535162d08d8944f14e72f8168e723ea024f46b8861292d47ae0e53ba419250f38e4a2a5fd1df2aaf3
+  metadata.gz: 99e55d28f19fe7d4cb9a2d18a066a12fa43ffc2dfe59b1e5ac3e2795202c67b122e0fce2a9862871accb936eb58320870588c7eb622b4ee714c3e7bcb22eb5bc
+  data.tar.gz: 12e216d00ceb2e16ca2d27711bc47449e0ff49438ad9b42d52ae677368624cf15c3c80babef8a70aa740e0cdee8b619697aae871fb2962767e87af2f633068c0

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [0.0.14] - 2018-09-23
+Added `lambda` (anonymous function). This is an initial implementation that doesn't support recursion yet.
+
+### Added
+- Class `SkmLambda` for representing a specific definition.
+
+### Changed
+- Class `Environment`. Now supports the nesting of environments. If an environment doesn't find a variable, then it forwards the serach to the outer environment.
+- File `grammar.rb` Added syntax rules for lambda expression.
+- Class `Runtime` added methods `nest` and `unnest` that adds or removes an nested environment.
+- Class `SkmBuilder`. Added method to implement the semantic action for `lambda` expressions.
+- Class `Tokenizer` Added keyword `lambda`
+- File `README.md` Added demo snippet with example of lambda expression.
+- Files `*_spec.rb` Added more tests. Skeem passes the 100 'RSpec examples' mark.
+
 ## [0.0.13] - 2018-09-18
 Added primitive `if` (conditional form)
 

data/README.md

@@ -27,11 +27,13 @@ Or install it yourself as:
 The __Skeem__ project has just started.  
 At this stage, the gem consists of a bare-bones interpreter.
 
+### Example 1 (Variable definition)
+
 ```ruby
   require 'skeem'
 
   schemer = Skeem::Interpreter.new
-  
+
   scheme_code =<<-SKEEM
     ; This heredoc consists of Scheme code...
     ; Let's define a Scheme variable
@@ -52,6 +54,32 @@ At this stage, the gem consists of a bare-bones interpreter.
   puts result.value # => 1764
 ```
 
+### Example 2 (Defining a function)
+Remark: Skeem 0.0.14 doesn't support recursive functions yet.
+
+```ruby
+  require 'skeem'
+
+  schemer = Skeem::Interpreter.new
+
+  scheme_code =<<-SKEEM
+    ; Let's implement the 'min' function
+    (define min (lambda(x y) (if (< x y) x y)))
+
+    ; What is the minimum of 2 and 3?
+    (min 2 3)
+  SKEEM
+
+  # Ask Ruby to execute Scheme code
+  result = schemer.run(scheme_code)
+  puts result.value # => 2
+
+  # Let's retry with other values
+  scheme_code = '(min 42 3)'
+  result = schemer.run(scheme_code)
+  puts result.value # => 3
+```
+
 Roadmap:
 - Extend language support
 - Implement REPL

data/lib/skeem/environment.rb

@@ -1,19 +1,51 @@
-require 'forwardable'
-
 module Skeem
   class Environment
-    extend Forwardable
-    def_delegator :@bindings, :empty?
-    
+    attr_reader :outer
+
     attr_reader(:bindings)
 
-    def initialize()
+    def initialize(outerEnv = nil)
       @bindings = {}
+      @outer = outerEnv
     end
 
     def define(anIdentifier, anExpression)
       raise StandardError, anIdentifier unless anIdentifier.kind_of?(String)
       @bindings[anIdentifier] = anExpression
     end
+
+    def fetch(anIdentifier)
+      found = bindings[anIdentifier]
+      if found.nil? && outer
+        found = outer.fetch(anIdentifier)
+      end
+
+      found
+    end
+
+    def empty?
+      my_result = bindings.empty?
+      if my_result && outer
+        my_result = outer.empty?
+      end
+
+      my_result
+    end
+
+    def size
+      my_result = bindings.size
+      my_result += outer.size if outer
+
+      my_result
+    end
+
+    def include?(anIdentifier)
+      my_result = bindings.include?(anIdentifier)
+      if my_result == false  && outer
+        my_result = outer.include?(anIdentifier)
+      end
+
+      my_result
+    end
   end # class
 end # module

data/lib/skeem/grammar.rb

@@ -11,14 +11,14 @@ module Skeem
     # Delimiters, separators...
     # add_terminals('APOSTROPHE', 'BACKQUOTE')
     add_terminals('LPAREN', 'RPAREN')
-    # add_terminals('PERIOD')
+    add_terminals('PERIOD')
 
     # Literal values...
     add_terminals('BOOLEAN', 'INTEGER', 'REAL')
     add_terminals('STRING_LIT', 'IDENTIFIER')
 
     # Keywords...
-    add_terminals('DEFINE', 'IF')
+    add_terminals('DEFINE', 'IF', 'LAMBDA')
 
     rule('program' => 'cmd_or_def_plus').as 'main'
     rule('cmd_or_def_plus' => 'cmd_or_def_plus cmd_or_def').as 'multiple_cmd_def'
@@ -30,6 +30,7 @@ module Skeem
     rule('expression' =>  'IDENTIFIER').as 'variable_reference'
     rule 'expression' =>  'literal'
     rule 'expression' =>  'procedure_call'
+    rule 'expression' =>  'lambda_expression'
     rule 'expression' =>  'conditional'
     rule 'literal' => 'self-evaluating'
     rule 'self-evaluating' => 'BOOLEAN'
@@ -41,6 +42,20 @@ module Skeem
     rule('operand_plus' => 'operand').as 'last_operand'
     rule 'operator' => 'expression'
     rule 'operand' => 'expression'
+    rule('lambda_expression' => 'LPAREN LAMBDA formals body RPAREN').as 'lambda_expression'
+    rule('formals' => 'LPAREN identifier_star RPAREN').as 'identifiers_as_formals'
+    rule 'formals' => 'IDENTIFIER'
+    rule 'formals' => 'LPAREN identifier_plus PERIOD IDENTIFIER RPAREN'
+    rule('identifier_star' => 'identifier_star IDENTIFIER').as 'identifier_star'
+    rule('identifier_star' => []).as 'no_identifier_yet'
+    rule 'identifier_plus' => 'identifier_plus IDENTIFIER'
+    rule 'identifier_plus' => 'IDENTIFIER'
+    rule('body' => 'definition_star sequence').as 'body'
+    rule 'definition_star' => 'definition_star definition'
+    rule 'definition_star' => []
+    rule('sequence' => 'command_star expression').as 'sequence'
+    rule('command_star' => 'command_star command').as 'multiple_commands'
+    rule('command_star' => []).as 'no_command_yet'
     rule('conditional' => 'LPAREN IF test consequent alternate RPAREN').as 'conditional'
     rule 'test' => 'expression'
     rule 'consequent' => 'expression'

data/lib/skeem/primitive_procedure.rb

@@ -5,11 +5,12 @@ module Skeem
     attr_reader(:identifier)
     attr_reader(:code)
 
-    def initialize(anId, aLambda)
+    def initialize(anId, aRubyLambda)
       @identifier = anId.kind_of?(String) ? SkmIdentifier.create(anId) : anId
-      @code = aLambda
+      @code = aRubyLambda
     end
 
+    # Arguments are positional in a primitive procedure.
     def call(aRuntime, aProcedureCall)
       args = aProcedureCall.operands
       return @code.call(aRuntime, args)

data/lib/skeem/runtime.rb

@@ -7,12 +7,23 @@ module Skeem
     end
 
     def include?(anIdentifier)
-      environment.bindings.include?(normalize_key(anIdentifier))
+      environment.include?(normalize_key(anIdentifier))
     end
 
     def define(aKey, anEntry)
       environment.define(normalize_key(aKey), anEntry)
     end
+    
+    def nest()
+      nested = Environment.new(environment)
+      @environment = nested
+    end
+    
+    def unnest()
+      raise StandardError, 'Cannot unnest environment' unless environment.outer
+      environment.bindings.clear
+      @environment = environment.outer
+    end
 
     private
 

data/lib/skeem/s_expr_builder.rb

@@ -82,10 +82,53 @@ module Skeem
       [theChildren.last]
     end
     
+    # rule('lambda_expression' => 'LPAREN LAMBDA formals body RPAREN').as 'lambda_expression'
+    def reduce_lambda_expression(_production, _range, _tokens, theChildren)
+      lmbd = SkmLambda.new(_range, theChildren[2], theChildren[3])
+      # puts lmbd.inspect
+      lmbd
+    end
+    
+    # rule('formals' => 'LPAREN identifier_star RPAREN').as 'identifiers_as_formals'
+    def reduce_identifiers_as_formals(_production, _range, _tokens, theChildren)
+      theChildren[1]
+    end
+
+    # rule('identifier_star' => 'identifier_star IDENTIFIER').as 'identifier_star'
+    def reduce_identifier_star(_production, _range, _tokens, theChildren)
+      theChildren[0] << theChildren[1]
+    end
+
+    # rule('identifier_star' => []).as 'no_identifier_yet'
+    def reduce_no_identifier_yet(_production, _range, _tokens, theChildren)
+      []
+    end
+
+    # rule('body' => 'definition_star sequence').as 'body'
+    def reduce_body(_production, _range, _tokens, theChildren)
+      definitions = theChildren[0].nil? ? [] : theChildren[0]
+      { defs: definitions, sequence: theChildren[1] }
+    end
+
+    # rule('sequence' => 'command_star expression').as 'sequence'
+    def reduce_sequence(_production, _range, _tokens, theChildren)
+      SkmList.new(theChildren[0] << theChildren[1])
+    end
+
+    # rule('command_star' => 'command_star command').as 'multiple_commands'
+    def reduce_multiple_commands(_production, _range, _tokens, theChildren)
+      theChildren[0] << theChildren[1]
+    end
+
+    # rule('command_star' => []).as 'no_command_yet'
+    def reduce_no_command_yet(_production, _range, _tokens, theChildren)
+      []
+    end
+
     # rule('conditional' => 'LPAREN IF test consequent alternate RPAREN').as 'conditional'
     def reduce_conditional(_production, aRange, _tokens, theChildren)
       SkmCondition.new(aRange, theChildren[2], theChildren[3], theChildren[4])
-    end    
+    end
   end # class
 end # module
 # End of file

data/lib/skeem/s_expr_nodes.rb

@@ -36,18 +36,18 @@ module Skeem
     def integer?
       false
     end
-    
+
     def boolean?
       false
     end
 
     def string?
       false
-    end    
+    end
 
     def symbol?
       false
-    end    
+    end
 
     # Abstract method.
     # Part of the 'visitee' role in Visitor design pattern.
@@ -55,6 +55,20 @@ module Skeem
     def accept(_visitor)
       raise NotImplementedError
     end
+
+   def inspect()
+      raise NotImplementedError
+    end
+
+    protected
+
+    def inspect_prefix
+      "<#{self.class.name}: "
+    end
+
+    def inspect_suffix
+      '>'
+    end
   end # struct
 
   # Abstract class. Root of class hierarchy needed for Interpreter
@@ -75,11 +89,6 @@ module Skeem
       return lightweight
     end
 
-    # This method can be overriden
-    def init_value(aValue)
-      @value = aValue
-    end
-
     def symbol()
       token.terminal
     end
@@ -88,6 +97,10 @@ module Skeem
       return self
     end
 
+    def inspect()
+      inspect_prefix + value.to_s + inspect_suffix
+    end
+
     def done!()
       # Do nothing
     end
@@ -97,12 +110,17 @@ module Skeem
     def accept(aVisitor)
       aVisitor.visit_terminal(self)
     end
+
+    # This method can be overriden
+    def init_value(aValue)
+      @value = aValue
+    end
   end # class
 
   class SkmBoolean < SkmTerminal
     def boolean?
       true
-    end  
+    end
   end # class
 
   class SkmNumber < SkmTerminal
@@ -128,10 +146,10 @@ module Skeem
     def init_value(aValue)
       super(aValue.dup)
     end
-    
+
     def string?
       true
-    end     
+    end
   end # class
 
   class SkmIdentifier < SkmTerminal
@@ -139,10 +157,10 @@ module Skeem
     def init_value(aValue)
       super(aValue.dup)
     end
-    
+
     def symbol?
       true
-    end     
+    end
   end # class
 
   class SkmReserved < SkmIdentifier
@@ -153,7 +171,7 @@ module Skeem
     attr_accessor(:members)
     extend Forwardable
 
-    def_delegators :@members, :first, :length, :empty?
+    def_delegators :@members, :each, :first, :length, :empty?
 
     def initialize(theMembers)
       super(nil)
@@ -202,8 +220,17 @@ module Skeem
       # Do nothing
     end
 
+    def inspect()
+      result = inspect_prefix
+      members.each { |elem| result << elem.inspect + ', ' }
+      result.sub!(/, $/, '')
+      result << inspect_suffix
+      result
+    end
+
     alias children members
     alias subnodes members
+    alias rest tail
   end # class
 
   class SkmDefinition < SkmElement
@@ -219,13 +246,32 @@ module Skeem
     def evaluate(aRuntime)
       var_key = variable.evaluate(aRuntime)
       aRuntime.define(var_key, self)
+      expression.evaluate(aRuntime) if expression.kind_of?(SkmLambda)
       self
     end
+
+    # call method should only invoked when the expression is a SkmLambda
+    def call(aRuntime, aProcedureCall)
+      unless expression.kind_of?(SkmLambda)
+        err_msg = "Expected a SkmLambda instead of #{expression.class}"
+        raise StandardError, err_msg
+      end
+      expression.call(aRuntime, aProcedureCall)
+    end
+
+    def inspect
+      result = inspect_prefix
+      result << variable.inspect
+      result << ', '
+      result << expression.inspect
+      result << inspect_suffix
+      result
+    end
   end # class
-  
+
   class SkmVariableReference  < SkmElement
     attr_reader :variable
-    
+
     def initialize(aPosition, aVariable)
       super(aPosition)
       @variable = aVariable
@@ -236,10 +282,10 @@ module Skeem
       unless aRuntime.include?(var_key.value)
         err = StandardError
         key = var_key.kind_of?(SkmIdentifier) ? var_key.value : var_key
-        err_msg = "Unknown variable '#{key}'"
+        err_msg = "Unbound variable: '#{key}'"
         raise err, err_msg
       end
-      definition = aRuntime.environment.bindings[var_key.value]
+      definition = aRuntime.environment.fetch(var_key.value)
       result = definition.expression.evaluate(aRuntime)
     end
 
@@ -248,7 +294,12 @@ module Skeem
     def value()
       variable.value
     end
-  end
+
+    def inspect
+      result = inspect_prefix + variable.inspect + inspect_suffix
+      result
+    end
+  end # class
 
   class ProcedureCall < SkmElement
     attr_reader :operator
@@ -273,13 +324,19 @@ module Skeem
         err_msg = "Unknown procedure '#{key}'"
         raise err, err_msg
       end
-      procedure = aRuntime.environment.bindings[var_key.value]
+      procedure = aRuntime.environment.fetch(var_key.value)
       result = procedure.call(aRuntime, self)
     end
 
+    def inspect
+      result = inspect_prefix + operator.inspect + ', '
+      result << operands.inspect + inspect_suffix
+      result
+    end
+
     alias children operands
   end # class
-  
+
   class SkmCondition < SkmElement
     attr_reader :test
     attr_reader :consequent
@@ -302,6 +359,95 @@ module Skeem
         condition_result = consequent.evaluate(aRuntime)
       end
     end
+
+    def inspect
+      result = inspect_prefix + '@test ' + test.inspect + ', '
+      result << '@consequent ' + consequent.inspect + ', '
+      result << '@alternate ' + alternate.inspect + inspect_suffix
+      result
+    end
+  end # class
+  
+=begin
+<Skeem::SkmLambda: 
+  @formals [<Skeem::SkmIdentifier: x>]
+  @definitions nil
+  @sequence <Skeem::SkmList: 
+    <Skeem::SkmCondition: 
+      @test <Skeem::ProcedureCall: <Skeem::SkmIdentifier: <>, 
+        <Skeem::SkmList: <Skeem::SkmVariableReference: <Skeem::SkmIdentifier: x>>, 
+        <Skeem::SkmInteger: 0>>>, 
+      @consequent <Skeem::ProcedureCall: 
+        <Skeem::SkmIdentifier: ->, 
+        <Skeem::SkmList: <Skeem::SkmVariableReference: <Skeem::SkmIdentifier: x>>>>,
+      @alternate <Skeem::SkmVariableReference: <Skeem::SkmIdentifier: x>>>>>
+=end
+
+  class SkmLambda < SkmElement
+    # @!attribute [r] formals
+    # @return [Array<SkmIdentifier>] the argument names
+    attr_reader :formals
+    attr_reader :definitions
+    attr_reader :sequence
+
+    def initialize(aPosition, theFormals, aBody)
+      super(aPosition)
+      @formals = theFormals
+      @definitions = aBody[:defs]
+      @sequence = aBody[:sequence]
+    end
+
+    def evaluate(aRuntime)
+      formals.map! { |param| param.evaluate(aRuntime) }
+    end
+
+    def call(aRuntime, aProcedureCall)
+      aRuntime.nest
+      bind_locals(aRuntime, aProcedureCall)
+      # TODO remove next line
+      # puts aRuntime.environment.inspect
+      result = evaluate_defs(aRuntime)
+      result = evaluate_sequence(aRuntime)
+      aRuntime.unnest
+
+      result
+    end
+
+    def inspect
+      result = inspect_prefix + '@formals ' + formals.inspect + ', '
+      result << '@definitions ' + definitions.inspect + ', '
+      result << '@sequence ' + sequence.inspect + inspect_suffix
+      result
+    end
+
+    private
+
+    def bind_locals(aRuntime, aProcedureCall)
+      arguments =  aProcedureCall.operands.members
+      formals.each_with_index do |arg_name, index|
+        arg = arguments[index]
+        if arg.nil?
+          p aProcedureCall.operands.members
+          raise StandardError, "Unbound variable: '#{arg_name.value}'"
+        end
+
+        a_def = SkmDefinition.new(position, arg_name, arg)
+        a_def.evaluate(aRuntime)
+      end
+    end
+
+    def evaluate_defs(aRuntime)
+      definitions.each { |a_def| a_def.evaluate(runtime) }
+    end
+
+    def evaluate_sequence(aRuntime)
+      result = nil
+      if sequence
+        sequence.each { |cmd| result = cmd.evaluate(aRuntime) }
+      end
+
+      result
+    end
   end # class
 end # module
 # End of file

data/lib/skeem/tokenizer.rb

@@ -30,6 +30,7 @@ module Skeem
       BEGIN
       IF
       DEFINE
+      LAMBDA
     ].map { |x| [x, x] } .to_h
 
     class ScanError < StandardError; end

data/lib/skeem/version.rb

@@ -1,3 +1,3 @@
 module Skeem
-  VERSION = '0.0.13'.freeze
+  VERSION = '0.0.14'.freeze
 end

data/spec/skeem/environment_spec.rb

@@ -4,12 +4,12 @@ require_relative '../../lib/skeem/environment' # Load the class under test
 module Skeem
   describe Environment do
     context 'Initialization:' do
-      it 'should be initialized without argument' do
+      it 'should be initialized with opional argument' do
         expect { Environment.new() }.not_to raise_error
       end
 
-      it 'should have no bindings' do
-        expect(subject.bindings).to be_empty
+      it 'should have no default bindings' do
+        expect(subject).to be_empty
       end
     end # context
 
@@ -17,11 +17,53 @@ module Skeem
       it 'should add entries' do
         entry = double('dummy')
         subject.define('dummy', entry)
-        expect(subject.bindings.size).to eq(1) 
+        expect(subject.size).to eq(1)
         expect(subject.bindings['dummy']).not_to be_nil
         expect(subject.bindings['dummy']).to eq(entry)
       end
+
+      it 'should know whether it is empty' do
+        # Case 1: no entry
+        expect(subject.empty?).to be_truthy
+
+        # Case 2: existing entry
+        entry = double('dummy')
+        subject.define('dummy', entry)
+        expect(subject.empty?).to be_falsey
+
+        # Case 3: entry defined in outer environment
+        nested = Environment.new(subject)
+        expect(nested.empty?).to be_falsey
+      end
+
+      it 'should retrieve entries' do
+        # Case 1: non-existing entry
+        expect(subject.fetch('dummy')).to be_nil
+
+        # Case 2: existing entry
+        entry = double('dummy')
+        subject.define('dummy', entry)
+        expect(subject.fetch('dummy')).to eq(entry)
+
+        # Case 3: entry defined in outer environment
+        nested = Environment.new(subject)
+        expect(nested.fetch('dummy')).to eq(entry)
+      end
+
+      it 'should know the total number of bindings' do
+        # Case 1: non-existing entry
+        expect(subject.size).to be_zero
+
+        # Case 2: existing entry
+        entry = double('dummy')
+        subject.define('dummy', entry)
+        expect(subject.size).to eq(1)
+
+        # Case 3: entry defined in outer environment
+        nested = Environment.new(subject)
+        expect(nested.size).to eq(1)
+      end
     end # context
-    
+
   end # describe
 end # module

data/spec/skeem/interpreter_spec.rb

@@ -77,13 +77,13 @@ module Skeem
         end
       end
     end # context
-   
-    context 'Built-in primitives' do      
+
+    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
@@ -103,9 +103,9 @@ SKEEM
         checks.each do |(skeem_expr, expectation)|
           result = subject.run(skeem_expr)
           expect(result.value).to eq(expectation)
-        end      
+        end
       end
-      
+
       it 'should implement the complete conditional form' do
          checks = [
           ['(if (> 3 2) "yes" "no")', 'yes'],
@@ -122,8 +122,49 @@ SKEEM
     (+ 3 2))
 SKEEM
         result = subject.run(source)
-        expect(result.value).to eq(1)      
+        expect(result.value).to eq(1)
+      end
+
+      it 'should implement the lambda function with one arg' do
+        source = <<-SKEEM
+  ; Simplified 'abs' function implementation
+  (define abs (lambda(x)
+    (if (< x 0) (- x) x)))
+SKEEM
+        subject.run(source)
+        result = subject.run('(abs -3)')
+        expect(result.value).to eq(3)
+        result = subject.run('(abs 0)')
+        expect(result.value).to eq(0)
+        result = subject.run('(abs 3)')
+        expect(result.value).to eq(3)
       end
+      
+      it 'should implement the lambda function with two args' do
+        source = <<-SKEEM
+  ; Simplified 'min' function implementation
+  (define min (lambda(x y)
+    (if (< x y) x y)))
+SKEEM
+        subject.run(source)
+        result = subject.run('(min 1 2)')
+        expect(result.value).to eq(1)
+        result = subject.run('(min 2 1)')
+        expect(result.value).to eq(1)
+        result = subject.run('(min 2 2)')
+        expect(result.value).to eq(2)
+      end      
+      
+      # it 'should implement recursive functions' do
+        # source = <<-SKEEM
+  # ; Example from R7RS section 4.1.5
+  # (define fact (lambda (n) 
+    # (if (<= n 1) 1 (* n (fact (- n 1))))))
+  # (fact 10)
+# SKEEM
+        # subject.run(source)
+        # expect(result.value).to eq(3628800)    
+      # end
     end # context
 
     context 'Built-in primitive procedures' do
@@ -234,7 +275,7 @@ SKEEM
           expect(result.value).to eq(expectation)
         end
       end
-      
+
       it 'should implement the greater or equal than operator' do
         checks = [
           ['(>= 3 2)', true],
@@ -248,7 +289,7 @@ SKEEM
           result = subject.run(skeem_expr)
           expect(result.value).to eq(expectation)
         end
-      end      
+      end
 
       it 'should implement the number? predicate' do
         checks = [

data/spec/skeem/runtime_spec.rb

@@ -6,7 +6,7 @@ module Skeem
   describe Runtime do
     let(:some_env) { Environment.new }
     subject { Runtime.new(some_env) }
-  
+
     context 'Initialization:' do
       it 'should be initialized with an environment' do
         expect { Runtime.new(Environment.new) }.not_to raise_error
@@ -21,15 +21,29 @@ module Skeem
       it 'should add entries to the environment' do
         entry = double('dummy')
         subject.define('dummy', entry)
-        expect(subject.environment.bindings.size).to eq(1)
+        expect(subject.environment.size).to eq(1)
       end
-      
+
       it 'should know the keys in the environment' do
         expect(subject.include?('dummy')).to be_falsey
         entry = double('dummy')
-        subject.define('dummy', entry)      
+        subject.define('dummy', entry)
         expect(subject.include?('dummy')).to be_truthy
       end
+
+      it 'should add nested environment' do
+        env_before = subject.environment
+        subject.nest
+        expect(subject.environment).not_to eq(env_before)
+        expect(subject.environment.outer).to eq(env_before)
+      end
+
+      it 'should remove nested environment' do
+        subject.nest
+        outer_before = subject.environment.outer
+        subject.unnest
+        expect(subject.environment).to eq(outer_before)
+      end
     end # context
   end # describe
 end # module

data/spec/skeem/s_expr_nodes_spec.rb

@@ -0,0 +1,411 @@
+require 'ostruct'
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/skeem/s_expr_nodes' # Load the classes under test
+
+module Skeem
+  describe SkmElement do
+    let(:pos) {double('fake-position') }
+    subject { SkmElement.new(pos) }
+
+    context 'Initialization:' do
+      it 'should be initialized with a position' do
+        expect { SkmElement.new(pos) }.not_to raise_error
+      end
+
+      it 'should know its position' do
+        expect(subject.position).to eq(pos)
+      end
+
+      # Default (overridable) behavior of SkmElement
+      it 'should react by default to predicates' do
+        expect(subject).not_to be_boolean
+        expect(subject).not_to be_number
+        expect(subject).not_to be_real
+        expect(subject).not_to be_integer
+        expect(subject).not_to be_string
+        expect(subject).not_to be_symbol
+      end
+    end # context
+  end # describe
+
+describe SkmTerminal do
+    let(:pos) { double('fake-position') }
+    let(:dummy_symbol) { double('fake-symbol') }
+    let(:sample_value) { 'sample-value' }
+    let(:dummy_token) do
+      obj = OpenStruct.new
+      obj.terminal = dummy_symbol
+      obj.lexeme = sample_value
+      obj
+    end
+    subject { SkmTerminal.new(dummy_token, pos) }
+
+    context 'Initialization:' do
+      it 'should be initialized with a token and a position' do
+        expect { SkmTerminal.new(dummy_token, pos) }.not_to raise_error
+      end
+
+      it 'should know its token' do
+        expect(subject.token).to eq(dummy_token)
+      end
+
+      it 'should know its value' do
+        expect(subject.value).to eq(sample_value)
+      end
+
+      it "should know the token's symbol" do
+        expect(subject.symbol).to eq(dummy_symbol)
+      end
+    end
+
+    context 'Provided services:' do
+      it 'should return its text representation' do
+        expect(subject.inspect).to eq("<Skeem::SkmTerminal: sample-value>")
+      end
+    end # context
+  end # describe
+
+describe SkmBoolean do
+    let(:pos) { double('fake-position') }
+    let(:dummy_symbol) { double('BOOLEAN') }
+    let(:sample_value) { false }
+    let(:dummy_token) do
+      obj = OpenStruct.new
+      obj.terminal = dummy_symbol
+      obj.lexeme = sample_value
+      obj
+    end
+    subject { SkmBoolean.new(dummy_token, pos) }
+
+    context 'Initialization:' do
+      it 'should be initialized with a token and a position' do
+        expect { SkmBoolean.new(dummy_token, pos) }.not_to raise_error
+      end
+
+      it 'should react positively to boolean? predicate' do
+        expect(subject).to be_boolean
+      end
+    end
+
+    context 'Provided services:' do
+      it 'should return its text representation' do
+        expect(subject.inspect).to eq('<Skeem::SkmBoolean: false>')
+      end
+    end # context
+  end # describe
+
+describe SkmNumber do
+    let(:pos) { double('fake-position') }
+    let(:dummy_symbol) { double('dummy') }
+    let(:sample_value) { 0.5100 }
+    let(:dummy_token) do
+      obj = OpenStruct.new
+      obj.terminal = dummy_symbol
+      obj.lexeme = sample_value
+      obj
+    end
+    subject { SkmNumber.new(dummy_token, pos) }
+
+    context 'Initialization:' do
+      it 'should be initialized with a token and a position' do
+        expect { SkmNumber.new(dummy_token, pos) }.not_to raise_error
+      end
+    end
+
+    context 'Provided services:' do
+      it 'should react positively to number? predicate' do
+        expect(subject).to be_number
+      end
+
+      it 'should return its text representation' do
+        expect(subject.inspect).to eq('<Skeem::SkmNumber: 0.51>')
+      end
+    end # context
+  end # describe
+
+describe SkmReal do
+    let(:pos) { double('fake-position') }
+    let(:dummy_symbol) { double('dummy') }
+    let(:sample_value) { 0.5100 }
+    let(:dummy_token) do
+      obj = OpenStruct.new
+      obj.terminal = dummy_symbol
+      obj.lexeme = sample_value
+      obj
+    end
+    subject { SkmReal.new(dummy_token, pos) }
+
+    context 'Provided services:' do
+      it 'should react positively to number? predicate' do
+        expect(subject).to be_number
+      end
+
+      it 'should react positively to real? predicate' do
+        expect(subject).to be_real
+      end
+    end
+  end # describe
+
+describe SkmInteger do
+    let(:pos) { double('fake-position') }
+    let(:dummy_symbol) { double('dummy') }
+    let(:sample_value) { 3 }
+    let(:dummy_token) do
+      obj = OpenStruct.new
+      obj.terminal = dummy_symbol
+      obj.lexeme = sample_value
+      obj
+    end
+    subject { SkmInteger.new(dummy_token, pos) }
+
+    context 'Provided services:' do
+      it 'should react positively to number? predicate' do
+        expect(subject).to be_number
+      end
+
+      it 'should react positively to real? predicate' do
+        expect(subject).to be_real
+      end
+
+      it 'should react positively to integer? predicate' do
+        expect(subject).to be_real
+      end
+    end
+  end # describe
+
+describe SkmString do
+    let(:pos) { double('fake-position') }
+    let(:dummy_symbol) { double('dummy') }
+    let(:sample_value) { 'Hello' }
+    let(:dummy_token) do
+      obj = OpenStruct.new
+      obj.terminal = dummy_symbol
+      obj.lexeme = sample_value
+      obj
+    end
+    subject { SkmString.new(dummy_token, pos) }
+
+    context 'Provided services:' do
+      it 'should react positively to string? predicate' do
+        expect(subject).to be_string
+      end
+
+      it 'should return its text representation' do
+        expect(subject.inspect).to eq('<Skeem::SkmString: Hello>')
+      end
+    end
+  end # describe
+
+describe SkmIdentifier do
+    let(:pos) { double('fake-position') }
+    let(:dummy_symbol) { double('dummy') }
+    let(:sample_value) { 'this-is-it!' }
+    let(:dummy_token) do
+      obj = OpenStruct.new
+      obj.terminal = dummy_symbol
+      obj.lexeme = sample_value
+      obj
+    end
+    subject { SkmIdentifier.new(dummy_token, pos) }
+
+    context 'Provided services:' do
+      it 'should react positively to symbol? predicate' do
+        expect(subject).to be_symbol
+      end
+
+      it 'should return its text representation' do
+        expect(subject.inspect).to eq('<Skeem::SkmIdentifier: this-is-it!>')
+      end
+    end # context
+  end # describe
+
+  describe SkmList do
+    let(:sample_members) { [1, 2, 3] }
+
+    subject { SkmList.new(sample_members) }
+
+    context 'Initialization:' do
+      it 'should be initialized with its members' do
+        expect{ SkmList.new(sample_members) }.not_to raise_error
+      end
+
+      it 'should know its members' do
+        expect(subject.members).to eq(sample_members)
+      end
+    end # context
+
+    context 'Provided services:' do
+      it 'should retrieve its first member' do
+        expect(subject.first).to eq(1)
+        expect(subject.head).to eq(1)
+      end
+
+      it 'should retrieve its tail members' do
+        expect(subject.tail.inspect).to eq('<Skeem::SkmList: 2, 3>')
+        expect(subject.rest.inspect).to eq('<Skeem::SkmList: 2, 3>')
+      end
+
+      it 'should return its text representation' do
+        expect(subject.inspect).to eq('<Skeem::SkmList: 1, 2, 3>')
+      end
+    end # context
+  end # describe
+
+
+  describe SkmDefinition do
+    let(:pos) { double('fake-position') }
+    let(:sample_symbol) { SkmIdentifier.create('this-is-it!') }
+    let(:sample_expr) { SkmInteger.create(10) }
+
+    subject { SkmDefinition.new(pos, sample_symbol, sample_expr) }
+
+    context 'Initialization:' do
+      it 'should be initialized with a symbol and an expression' do
+        expect{ SkmDefinition.new(pos, sample_symbol, sample_expr) }.not_to raise_error
+      end
+
+      it 'should know its variable' do
+        expect(subject.variable).to eq(sample_symbol)
+      end
+
+      it 'should know its expression' do
+        expect(subject.expression).to eq(sample_expr)
+      end
+    end # context
+
+    context 'Provided services:' do
+      it 'should return its text representation' do
+        txt1 = '<Skeem::SkmDefinition: <Skeem::SkmIdentifier: this-is-it!>,'
+        txt2 = ' <Skeem::SkmInteger: 10>>'
+        expect(subject.inspect).to eq(txt1 + txt2)
+      end
+    end # context
+  end # describe
+
+  describe SkmVariableReference do
+    let(:pos) { double('fake-position') }
+    let(:sample_symbol) { SkmIdentifier.create('this-is-it!') }
+
+    subject { SkmVariableReference.new(pos, sample_symbol) }
+
+    context 'Initialization:' do
+      it 'should be initialized with a position and a symbol' do
+        expect{ SkmVariableReference.new(pos, sample_symbol) }.not_to raise_error
+      end
+
+      it 'should know its variable' do
+        expect(subject.variable).to eq(sample_symbol)
+      end
+    end # context
+
+    context 'Provided services:' do
+      it 'should return its text representation' do
+        txt1 = '<Skeem::SkmVariableReference: <Skeem::SkmIdentifier: this-is-it!>>'
+        expect(subject.inspect).to eq(txt1)
+      end
+    end # context
+  end # describe
+
+  describe ProcedureCall do
+     let(:pos) { double('fake-position') }
+    let(:operator) { SkmIdentifier.create('+') }
+    let(:operands) { [1, 2, 3] }
+
+    subject { ProcedureCall.new(pos, operator, operands) }
+
+    context 'Initialization:' do
+      it 'should be initialized with an operator symbol and its operands' do
+        expect{ ProcedureCall.new(pos, operator, operands) }.not_to raise_error
+      end
+
+      it 'should know its operator' do
+        expect(subject.operator).to eq(operator)
+      end
+
+      it 'should know its operands' do
+        expect(subject.operands.inspect).to eq('<Skeem::SkmList: 1, 2, 3>')
+      end
+    end # context
+
+    context 'Provided services:' do
+      it 'should return its text representation' do
+        txt1 = '<Skeem::ProcedureCall: <Skeem::SkmIdentifier: +>, '
+        txt2 = '<Skeem::SkmList: 1, 2, 3>>'
+        expect(subject.inspect).to eq(txt1 + txt2)
+      end
+    end # context
+  end # describe
+
+  describe SkmCondition do
+    let(:pos) { double('fake-position') }
+    let(:s_test) { double('fake-test') }
+    let(:s_consequent) { double('fake-consequent') }
+    let(:s_alt) { double('fake-alternate') }
+
+    subject { SkmCondition.new(pos, s_test, s_consequent, s_alt) }
+
+    context 'Initialization:' do
+      it 'should be initialized with a pos and 3 expressions' do
+        expect{ SkmCondition.new(pos, s_test, s_consequent, s_alt) }.not_to raise_error
+      end
+
+      it 'should know its test' do
+        expect(subject.test).to eq(s_test)
+      end
+
+      it 'should know its consequent' do
+        expect(subject.consequent).to eq(s_consequent)
+      end
+
+      it 'should know its alternate' do
+        expect(subject.alternate).to eq(s_alt)
+      end
+    end # context
+
+    context 'Provided services:' do
+      it 'should return its text representation' do
+        txt1 = '<Skeem::SkmCondition: @test #<Double "fake-test">, '
+        txt2 = '@consequent #<Double "fake-consequent">, '
+        txt3 = '@alternate #<Double "fake-alternate">>'
+        expect(subject.inspect).to eq(txt1 + txt2 + txt3)
+      end
+    end # context
+  end # describe
+
+  describe SkmLambda do
+    let(:pos) { double('fake-position') }
+    let(:s_formals) { double('fake-formals') }
+    let(:s_defs) { double('fake-definitions') }
+    let(:s_sequence) { double('fake-sequence') }
+    let(:s_body) do { defs: s_defs, sequence: s_sequence } end
+
+    subject { SkmLambda.new(pos, s_formals, s_body) }
+    
+    context 'Initialization:' do
+      it 'should be initialized with a pos and 3 expressions' do
+        expect{ SkmLambda.new(pos, s_formals, s_body) }.not_to raise_error
+      end
+
+      it 'should know its formals' do
+        expect(subject.formals).to eq(s_formals)
+      end
+
+      it 'should know its definitions' do
+        expect(subject.definitions).to eq(s_defs)
+      end
+
+      it 'should know its sequence' do
+        expect(subject.sequence).to eq(s_sequence)
+      end
+    end # context
+
+    context 'Provided services:' do
+      it 'should return its text representation' do
+        txt1 = '<Skeem::SkmLambda: @formals #<Double "fake-formals">, '
+        txt2 = '@definitions #<Double "fake-definitions">, '
+        txt3 = '@sequence #<Double "fake-sequence">>'
+        expect(subject.inspect).to eq(txt1 + txt2 + txt3)
+      end
+    end # context
+  end # describe
+end # module

data/spec/skeem/tokenizer_spec.rb

@@ -134,7 +134,11 @@ module Skeem
         examples.each do |input|
           subject.reinitialize(input)
           token = subject.tokens.first
-          expect(token.terminal).to eq('IDENTIFIER')
+          if token.lexeme == 'lambda'
+            expect(token.terminal).to eq('LAMBDA')
+          else
+            expect(token.terminal).to eq('IDENTIFIER')
+          end
           expect(token.lexeme).to eq(input)
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skeem
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.14
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-18 00:00:00.000000000 Z
+date: 2018-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -104,6 +104,7 @@ files:
 - spec/skeem/parser_spec.rb
 - spec/skeem/primitive/primitive_builder_spec.rb
 - spec/skeem/runtime_spec.rb
+- spec/skeem/s_expr_nodes_spec.rb
 - spec/skeem/tokenizer_spec.rb
 - spec/skeem_spec.rb
 - spec/spec_helper.rb
@@ -139,5 +140,6 @@ test_files:
 - spec/skeem/parser_spec.rb
 - spec/skeem/primitive/primitive_builder_spec.rb
 - spec/skeem/runtime_spec.rb
+- spec/skeem/s_expr_nodes_spec.rb
 - spec/skeem/tokenizer_spec.rb
 - spec/skeem_spec.rb