mini_kraken 0.2.02 → 0.2.03

data/lib/mini_kraken/core/outcome.rb

@@ -24,7 +24,11 @@ unless MiniKraken::Core.constants(false).include? :Outcome
           new(:"#s", aParent)
         end
 
-        def successful?
+        def failure?
+          resultant != :"#s"
+        end
+
+        def success?
           resultant == :"#s"
         end
 
@@ -39,6 +43,12 @@ unless MiniKraken::Core.constants(false).include? :Outcome
           are_equal
         end
 
+        # Remove associations of variables of this environment, if
+        # persistence flag is set to false.
+        def prune!
+          parent.prune(self)
+        end
+
         protected
 
         def introspect

data/lib/mini_kraken/core/variable_ref.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'term'
+require_relative 'designation'
 require_relative 'any_value'
 
 module MiniKraken
@@ -15,6 +16,11 @@ module MiniKraken
       def initialize(aName)
         super()
         init_designation(aName)
+        name.freeze
+      end
+
+      def to_s
+        name
       end
 
       # @param aValue [Term]

data/lib/mini_kraken/core/vocabulary.rb

@@ -171,7 +171,7 @@ module MiniKraken
         to_fuse.map { |i_name| i_name2var(i_name) }
       end
 
-      # Fuse the given variables, that is:
+      # Fuse the given variables:
       # Collect all their associations
       # Put them under a new internal name
       # Remove all entries from old internal names
@@ -395,12 +395,16 @@ module MiniKraken
         name2var(aVarName) ? true : false
       end
 
+      def prune(anOutcome)
+        anOutcome # Don't touch outcome
+      end
+
       def inspect
         result = +"#<#{self.class.name}:#{object_id.to_s(16)} @parent="
         if parent
           result << "#<#{parent.class.name}:#{parent.object_id.to_s(16)}>"
         else
-          result << nil
+          result << 'nil'
         end
         result << introspect
         result << '>'

data/lib/mini_kraken/glue/dsl.rb

@@ -12,6 +12,7 @@ require_relative '../core/fail'
 require_relative '../core/formal_arg'
 require_relative '../core/formal_ref'
 require_relative '../glue/fresh_env'
+require_relative '../glue/fresh_env_factory'
 require_relative '../core/goal_template'
 require_relative '../core/k_boolean'
 require_relative '../core/k_symbol'
@@ -39,7 +40,7 @@ module MiniKraken
         # require 'debug'
         args = goals.map do |goal_maybe|
           if goal_maybe.kind_of?(Array)
-            goal_maybe.map { |g| convert(g)}
+            goal_maybe.map { |g| convert(g) }
           else
             convert(goal_maybe)
           end
@@ -98,14 +99,22 @@ module MiniKraken
 
       def fresh(var_names, goal)
         vars = nil
-
-        if var_names.kind_of?(String) || var_names.kind_of?(Core::VariableRef)
-          vars = [var_names]
+        if @dsl_mode == :defrel
+          if var_names.kind_of?(String)
+            vars = [var_names]
+          else
+            vars = var_names
+          end
+          FreshEnvFactory.new(vars, goal)
         else
-          vars = var_names
-        end
+          if var_names.kind_of?(String) || var_names.kind_of?(Core::VariableRef)
+            vars = [var_names]
+          else
+            vars = var_names
+          end
 
-        FreshEnv.new(vars, goal)
+          FreshEnv.new(vars, goal)
+        end
       end
 
       def list(*members)
@@ -158,7 +167,7 @@ module MiniKraken
           when Core::FormalRef
             converted = anArgument
           when FreshEnv
-            converted = anArgument            
+            converted = anArgument
           when Core::Goal
             converted = anArgument
           when Core::GoalTemplate

data/lib/mini_kraken/glue/fresh_env.rb

@@ -2,13 +2,14 @@
 
 require_relative '../core/environment'
 require_relative '../core/conj2'
+require_relative '../core/goal_template'
 require_relative '../core/variable'
 
 module MiniKraken
   module Glue
     # A combination of an Environment (= a scope for one or more variables)
     # and a goal. It quacks like a Goal object: when receiving the attain message,
-    # it attempt to achieve its given goal.
+    # it attempts to achieve its given goal.
     # (fresh (x) (== 'pea q))
     # Introduces the new variable 'x'
     # Takes a list of names and a goal-like object
@@ -17,22 +18,45 @@ module MiniKraken
       # @return [Goal]
       attr_reader :goal
 
+      # @return [TrueClass, FalseClass] Do associations persist after goal exec?
+      attr_reader :persistent
+
       # @param theNames [Array<String>] The variable names
       # @param aGoal [Goal, Array<Goal>] The goal to achieve or the conjunction of them.
-      def initialize(theNames, aGoal)
+      def initialize(theNames, aGoal, persistence = true)
         super()
         @goal = valid_goal(aGoal)
-        theNames.each { |nm| add_var(Core::Variable.new(nm)) }
+        theNames.each do |nm|
+          var = Core::Variable.new(nm)
+          add_var(var)
+        end
+        @persistent = persistence
       end
 
       # Attempt to achieve the goal given this environment
       # @param aParent [Environment]
       # @return [Fiber<Outcome>] A Fiber object that will generate the results.
       def attain(aParent)
+        # require 'debug'
         self.parent = aParent
         goal.attain(self)
       end
 
+      # Remove associations of variables of this environment, if
+      # persistence flag is set to false.
+      def prune(anOutcome)
+        return super(anOutcome) if persistent
+
+        vars.each_value do |v|
+          v_name = v.name
+          if anOutcome.associations.include?(v_name)
+            anOutcome.associations.delete(v_name)
+          end
+        end
+
+        anOutcome
+      end
+
       protected
 
       def introspect
@@ -49,6 +73,8 @@ module MiniKraken
             result = aGoal
           when FreshEnv
             result = aGoal
+          when Core::GoalTemplate
+            result = aGoal
           when Array # an Array of Goal?..
             goal_array = aGoal
             loop do
@@ -66,6 +92,8 @@ module MiniKraken
               end
               goal_array = conjunctions
             end
+          else
+            raise StandardError, "Cannot handle argumment type #{aGoal.class}"
         end
 
         result

data/lib/mini_kraken/glue/fresh_env_factory.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative '../core/environment'
+require_relative '../core/conj2'
+require_relative '../core/goal_template'
+require_relative '../core/variable'
+require_relative 'fresh_env'
+
+module MiniKraken
+  module Glue
+    # A combination of an Environment (= a scope for one or more variables)
+    # and a goal. It quacks like a Goal template object: when receiving the
+    # instantiate message, it creates a FreshEnv.
+    class FreshEnvFactory
+      # @return [Array<String>] The names of variables to be.
+      attr_reader :names
+
+      # @return [GoalTemplate] The goal template
+      attr_reader :goal_template
+
+      # @param theNames [Array<String>] The names of variables to build.
+      # @param aGoal [GoalTemplate, Array<Goal>] The goal template(s)
+      def initialize(theNames, aGoalTemplate)
+        @goal_template = valid_goal_template(aGoalTemplate)
+        @names = valid_names(theNames)
+      end
+
+      # Factory method: Create a goal object.
+      # @param formals [Array<FormalArg>] Array of formal arguments
+      # @param actuals [Array<GoalArg>] Array of actual arguments
+      # @return [Goal] instantiate a goal object given the actuals and environment
+      def instantiate(formals, actuals)
+        # require 'debug'
+        goal = goal_template.instantiate(formals, actuals)
+        FreshEnv.new(names, goal, false)
+      end
+
+      protected
+
+      def introspect
+        +", @names=[#{names.join(', ')}]"
+      end
+
+      private
+
+      def valid_names(theNames)
+        theNames
+      end
+
+      def valid_goal_template(aGoalTemplate)
+        result = nil
+
+        case aGoalTemplate
+          when FreshEnvFactory
+            result = aGoalTemplate
+          when Core::GoalTemplate
+            result = aGoalTemplate
+          # when Array # an Array of Goal?..
+            # goal_array = aGoalTemplate
+            # loop do
+              # conjunctions = []
+              # goal_array.each_slice(2) do |uno_duo|
+                # if uno_duo.size == 2
+                  # conjunctions << Core::GoalTemplate.new(Core::Conj2.instance, uno_duo)
+                # else
+                  # conjunctions << uno_duo[0]
+                # end
+              # end
+              # if conjunctions.size == 1
+                # result = conjunctions[0]
+                # break
+              # end
+              # goal_array = conjunctions
+            # end
+          else
+            raise StandardError, "Cannot handle argumment type #{aGoalTemplate.class}"
+        end
+
+        result
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/glue/run_star_expression.rb

@@ -27,7 +27,7 @@ module MiniKraken
           outcome = solver.resume
           break if outcome.nil?
 
-          env.propagate(outcome) if result.empty? && outcome.successful?
+          env.propagate(outcome) if result.empty? && outcome.success?
           result << build_solution(outcome)
         end
 
@@ -39,7 +39,7 @@ module MiniKraken
       # @return [Array] A vector of assignment for each variable
       def build_solution(outcome)
         env.vars.values.map do |var|
-          outcome.successful? ? var.quote(outcome) : nil
+          outcome.success? ? var.quote(outcome) : nil
         end
       end
 

data/lib/mini_kraken/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MiniKraken
-  VERSION = '0.2.02'
+  VERSION = '0.2.03'
 end

data/spec/core/conde_spec.rb

@@ -60,7 +60,7 @@ module MiniKraken
 
         it 'should fail when all goals fail' do
           solver = subject.solver_for([fails, fails, fails], env)
-          expect(solver.resume).not_to be_successful
+          expect(solver.resume).not_to be_success
           expect(solver.resume).to be_nil
         end
 
@@ -68,7 +68,7 @@ module MiniKraken
           subgoal = Goal.new(Equals.instance, [olive, ref_q])
           solver = subject.solver_for([subgoal, fails, fails], env)
           outcome = solver.resume
-          expect(outcome).to be_successful
+          expect(outcome).to be_success
           expect(outcome.associations['q'].first.value).to eq(olive)
           expect(solver.resume).to be_nil
         end
@@ -77,7 +77,7 @@ module MiniKraken
           subgoal = Goal.new(Equals.instance, [oil, ref_q])
           solver = subject.solver_for([fails, subgoal, fails], env)
           outcome = solver.resume
-          expect(outcome).to be_successful
+          expect(outcome).to be_success
           expect(outcome.associations['q'].first.value).to eq(oil)
           expect(solver.resume).to be_nil
         end
@@ -86,7 +86,7 @@ module MiniKraken
           subgoal = Goal.new(Equals.instance, [oil, ref_q])
           solver = subject.solver_for([fails, fails, subgoal], env)
           outcome = solver.resume
-          expect(outcome).to be_successful
+          expect(outcome).to be_success
           expect(outcome.associations['q'].first.value).to eq(oil)
           expect(solver.resume).to be_nil
         end
@@ -100,17 +100,17 @@ module MiniKraken
 
           # First solution
           outcome1 = solver.resume
-          expect(outcome1).to be_successful
+          expect(outcome1).to be_success
           expect(outcome1.associations['q'].first.value).to eq(olive)
 
           # Second solution
           outcome2 = solver.resume
-          expect(outcome2).to be_successful
+          expect(outcome2).to be_success
           expect(outcome2.associations['q'].first.value).to eq(oil)
 
           # Third solution
           outcome3 = solver.resume
-          expect(outcome3).to be_successful
+          expect(outcome3).to be_success
           expect(outcome3.associations['q'].first.value).to eq(pea)
 
           expect(solver.resume).to be_nil
@@ -129,13 +129,13 @@ module MiniKraken
 
           # First solution
           outcome1 = solver.resume
-          expect(outcome1).to be_successful
+          expect(outcome1).to be_success
           expect(outcome1.associations['x'].first.value).to eq(split)
           expect(outcome1.associations['y'].first.value).to eq(pea)
 
           # Second solution
           outcome2 = solver.resume
-          expect(outcome2).to be_successful
+          expect(outcome2).to be_success
           expect(outcome2.associations['x'].first.value).to eq(red)
           expect(outcome2.associations['y'].first.value).to eq(bean)
 

data/spec/core/conj2_spec.rb

@@ -47,12 +47,12 @@ module MiniKraken
         it 'should yield one failure if one of the goal is fail' do
           # Fail as first argument
           solver = subject.solver_for([fails, succeeds], env)
-          expect(solver.resume).not_to be_successful
+          expect(solver.resume).not_to be_success
           expect(solver.resume).to be_nil
 
           # Fail as second argument
           solver = subject.solver_for([succeeds, fails], env)
-          expect(solver.resume).not_to be_successful
+          expect(solver.resume).not_to be_success
           expect(solver.resume).to be_nil
         end
 
@@ -60,7 +60,7 @@ module MiniKraken
           # Covers frame 1-50
           solver = subject.solver_for([succeeds, succeeds], env)
           outcome = solver.resume
-          expect(outcome).to be_successful
+          expect(outcome).to be_success
           expect(outcome.associations).to be_empty
           expect(solver.resume).to be_nil
         end
@@ -71,7 +71,7 @@ module MiniKraken
           sub_goal = Goal.new(Equals.instance, [corn, ref_q])
           solver = subject.solver_for([succeeds, sub_goal], env)
           outcome = solver.resume
-          expect(outcome).to be_successful
+          expect(outcome).to be_success
           expect(outcome.associations).not_to be_empty
           expect(outcome.associations['q'].first.value).to eq(corn)
         end
@@ -82,7 +82,7 @@ module MiniKraken
           sub_goal = Goal.new(Equals.instance, [corn, ref_q])
           solver = subject.solver_for([fails, sub_goal], env)
           outcome = solver.resume
-          expect(outcome).not_to be_successful
+          expect(outcome).not_to be_success
           expect(outcome.associations).to be_empty
         end
 
@@ -93,7 +93,7 @@ module MiniKraken
           sub_goal2 = Goal.new(Equals.instance, [meal, ref_q])
           solver = subject.solver_for([sub_goal1, sub_goal2], env)
           outcome = solver.resume
-          expect(outcome).not_to be_successful
+          expect(outcome).not_to be_success
           expect(outcome.associations).to be_empty
         end
 
@@ -104,7 +104,7 @@ module MiniKraken
           sub_goal2 = Goal.new(Equals.instance, [corn, ref_q])
           solver = subject.solver_for([sub_goal1, sub_goal2], env)
           outcome = solver.resume
-          expect(outcome).to be_successful
+          expect(outcome).to be_success
           expect(outcome.associations).not_to be_empty
           expect(outcome.associations['q'].first.value).to eq(corn)
         end

data/spec/core/cons_cell_visitor_spec.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/mini_kraken/core/k_symbol'
+require_relative '../../lib/mini_kraken/core/variable_ref'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/cons_cell_visitor'
+
+
+module MiniKraken
+  module Core
+    describe ConsCellVisitor do
+      let(:pea) { KSymbol.new(:pea) }
+      let(:pod) { KSymbol.new(:pod) }
+      let(:corn) { KSymbol.new(:corn) }
+      let(:ref_q) { VariableRef.new('q') }
+      let(:l_pea) { ConsCell.new(pea) }
+      let(:l_pea_pod) { ConsCell.new(pea, ConsCell.new(pod)) }
+      let(:l_pea_pod_corn) { ConsCell.new(pea, ConsCell.new(pod, ConsCell.new(corn))) }
+      subject { ConsCellVisitor }
+
+      context 'Provided services:' do
+        it 'acts as a factory of Enumerator' do
+          expect(subject.df_visitor(l_pea)).to be_kind_of(Fiber)
+        end
+      end # context
+
+      context 'proper list visiting:' do
+        it 'can visit a null list' do
+          null_list = ConsCell.new(nil)
+          visitor = subject.df_visitor(null_list)
+          expect(visitor.resume).to eq([:car, null_list])
+          expect(visitor.resume).to eq([:car, nil])
+          expect(visitor.resume).to eq([:cdr, nil])
+          expect(visitor.resume).to eq([:stop, nil])
+        end
+
+        it 'can visit a single element proper list' do
+          visitor = subject.df_visitor(l_pea)
+          expect(visitor.resume).to eq([:car, l_pea])
+          expect(visitor.resume).to eq([:car, pea])
+          expect(visitor.resume).to eq([:cdr, nil])
+          expect(visitor.resume).to eq([:stop, nil])
+        end
+
+        it 'can visit a two elements proper list' do
+          visitor = subject.df_visitor(l_pea_pod)
+          expect(visitor.resume).to eq([:car, l_pea_pod])
+          expect(visitor.resume).to eq([:car, pea])
+          expect(visitor.resume).to eq([:cdr, l_pea_pod.cdr])
+          expect(visitor.resume).to eq([:car, pod])
+          expect(visitor.resume).to eq([:cdr, nil])
+          expect(visitor.resume).to eq([:stop, nil])
+        end
+
+        it 'can visit a three elements proper list' do
+          visitor = subject.df_visitor(l_pea_pod_corn)
+          expect(visitor.resume).to eq([:car, l_pea_pod_corn])
+          expect(visitor.resume).to eq([:car, pea])
+          expect(visitor.resume).to eq([:cdr, l_pea_pod_corn.cdr])
+          expect(visitor.resume).to eq([:car, pod])
+          expect(visitor.resume).to eq([:cdr, l_pea_pod_corn.cdr.cdr])
+          expect(visitor.resume).to eq([:car, corn])
+          expect(visitor.resume).to eq([:cdr, nil])
+          expect(visitor.resume).to eq([:stop, nil])
+        end
+      end # context
+
+      context 'improper list visiting:' do
+        it 'can visit a single element improper list' do
+          l_improper = ConsCell.new(nil, pea)
+          visitor = subject.df_visitor(l_improper)
+          expect(visitor.resume).to eq([:car, l_improper])
+          expect(visitor.resume).to eq([:car, nil])
+          expect(visitor.resume).to eq([:cdr, pea])
+          expect(visitor.resume).to eq([:stop, nil])
+        end
+
+        it 'can visit a two elements improper list' do
+          l_improper = ConsCell.new(pea, pod)
+          visitor = subject.df_visitor(l_improper)
+          expect(visitor.resume).to eq([:car, l_improper])
+          expect(visitor.resume).to eq([:car, pea])
+          expect(visitor.resume).to eq([:cdr, pod])
+          expect(visitor.resume).to eq([:stop, nil])
+        end
+
+        it 'can visit a three elements improper list' do
+          l_improper = ConsCell.new(pea, ConsCell.new(pod, corn))
+          visitor = subject.df_visitor(l_improper)
+          expect(visitor.resume).to eq([:car, l_improper])
+          expect(visitor.resume).to eq([:car, pea])
+          expect(visitor.resume).to eq([:cdr, l_improper.cdr])
+          expect(visitor.resume).to eq([:car, pod])
+          expect(visitor.resume).to eq([:cdr, corn])
+          expect(visitor.resume).to eq([:stop, nil])
+        end
+      end # context
+
+      context 'Skip visit of children of a ConsCell:' do
+        it 'can skip the visit of null list children' do
+          null_list = ConsCell.new(nil)
+          visitor = subject.df_visitor(null_list)
+
+          # Tell to skip children by passing a true value to resume
+          expect(visitor.resume(true)).to eq([:car, null_list])
+          expect(visitor.resume).to eq([:stop, nil])
+        end
+
+        it 'can skip the visit of some children' do
+          tree = ConsCell.new(pea, ConsCell.new(l_pea_pod, ConsCell.new(corn)))
+          expect(tree.to_s).to eq('(:pea (:pea :pod) :corn)')
+          visitor = subject.df_visitor(tree)
+          expect(visitor.resume).to eq([:car, tree])
+          expect(visitor.resume).to eq([:car, pea])
+          expect(visitor.resume).to eq([:cdr, tree.cdr])
+          expect(visitor.resume).to eq([:car, l_pea_pod])
+
+          # Tell to skip children by passing a true value to resume
+          expect(visitor.resume(true)).to eq([:cdr, tree.cdr.cdr])
+          expect(visitor.resume).to eq([:car, corn])
+          expect(visitor.resume).to eq([:cdr, nil])
+          expect(visitor.resume).to eq([:stop, nil])
+        end
+      end # context
+
+      context 'Circular structures visiting:' do
+        it 'should cope with a circular graph' do
+          second_cell = ConsCell.new(pod)
+          first_cell = ConsCell.new(pea, second_cell)
+          second_cell.instance_variable_set(:@car, first_cell) # Ugly!
+
+          visitor = subject.df_visitor(first_cell)
+          expect(visitor.resume).to eq([:car, first_cell])
+          expect(visitor.resume).to eq([:car, pea])
+          expect(visitor.resume).to eq([:cdr, second_cell])
+          expect(visitor.resume).to eq([:cdr, nil]) # Skip car (was already visited)
+          expect(visitor.resume).to eq([:stop, nil])
+        end
+      end # context
+    end # describe
+  end # module
+end # module