mini_kraken 0.1.12 → 0.2.03

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
 
@@ -38,11 +38,9 @@ module MiniKraken
 
       # @return [Array] A vector of assignment for each variable
       def build_solution(outcome)
-        sol = env.vars.values.map do |var|
-          outcome.successful? ? var.quote(outcome) : nil
+        env.vars.values.map do |var|
+          outcome.success? ? var.quote(outcome) : nil
         end
-
-        sol
       end
 
       # Transform the solutions into sequence of conscells.

data/lib/mini_kraken/version.rb

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

data/mini_kraken.gemspec

@@ -9,6 +9,7 @@ module PkgExtending
   def self.pkg_files(aPackage)
     file_list = Dir[
       '.rspec',
+      '.rubocop.yml',
       '.travis.yml',
       'Gemfile',
       'Rakefile',
@@ -19,7 +20,8 @@ module PkgExtending
       'bin/*.rb',
       'lib/*.*',
       'lib/**/*.rb',
-      'spec/**/*.rb'
+      'spec/**/*.rb',
+      'spec/.rubocop.yml'
     ]
     aPackage.files = file_list
     aPackage.test_files = Dir['spec/**/*_spec.rb']
@@ -38,8 +40,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Dimitri Geshef']
   spec.email         = ['famished.tiger@yahoo.com']
 
-  spec.summary       = %q{Implementation of Minikanren language in Ruby. WIP}
-  spec.description   = %q{Implementation of Minikanren language in Ruby. WIP}
+  spec.summary       = 'Implementation of Minikanren language in Ruby. WIP'
+  spec.description   = 'Implementation of Minikanren language in Ruby. WIP'
   spec.homepage      = 'https://github.com/famished-tiger/mini_kraken'
   spec.license       = 'MIT'
 
@@ -47,6 +49,7 @@ Gem::Specification.new do |spec|
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
+  spec.required_ruby_version = '~> 2.4'
 
   PkgExtending.pkg_files(spec)
   PkgExtending.pkg_documentation(spec)

data/spec/.rubocop.yml

@@ -0,0 +1,13 @@
+inherit_from: ../.rubocop.yml
+
+# RSpec expectation lines can be very lenghty
+Layout/LineLength:
+  Max: 99
+
+# RSpec contexts can be very lenghty
+Metrics/BlockLength:
+  Max: 1000
+
+# RSpec modules can be very lenghty  
+Metrics/ModuleLength:
+  Max: 1000

data/spec/core/conde_spec.rb

@@ -58,9 +58,9 @@ module MiniKraken
           expect { subject.solver_for([pea, succeeds], env) }.to raise_error(err)
         end
 
-        it 'should fails if when all goals fail' do
+        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_spec.rb

@@ -11,6 +11,7 @@ module MiniKraken
     describe ConsCell do
       let(:pea) { KSymbol.new(:pea) }
       let(:pod) { KSymbol.new(:pod) }
+      let(:corn) { KSymbol.new(:corn) }
       subject { ConsCell.new(pea, pod) }
 
       context 'Initialization:' do
@@ -39,6 +40,12 @@ module MiniKraken
           expect(ConsCell.new(nil, nil)).to be_null
           expect(NullList).to be_null
         end
+
+        it 'simplifies cdr if its referencing a null list' do
+          instance = ConsCell.new(pea, NullList)
+          expect(instance.car).to eq(pea)
+          expect(instance.cdr).to be_nil
+        end
       end # context
 
       context 'Provided services:' do
@@ -66,6 +73,34 @@ module MiniKraken
           expect(instance.car).to eq(pea)
           expect(instance.cdr).to eq(trail)
         end
+
+        it 'should provide a list representation of itself' do
+          # Case of null list
+          expect(NullList.to_s).to eq '()'
+
+          # Case of one element proper list
+          cell = ConsCell.new(pea)
+          expect(cell.to_s).to eq '(:pea)'
+
+          # Case of two elements proper list
+          cell = ConsCell.new(pea, ConsCell.new(pod))
+          expect(cell.to_s).to eq '(:pea :pod)'
+
+          # Case of two elements improper list
+          expect(subject.to_s).to eq '(:pea . :pod)'
+
+          # Case of three elements proper list
+          cell = ConsCell.new(pea, ConsCell.new(pod, ConsCell.new(corn)))
+          expect(cell.to_s).to eq '(:pea :pod :corn)'
+
+          # Case of three elements improper list
+          cell = ConsCell.new(pea, ConsCell.new(pod, corn))
+          expect(cell.to_s).to eq '(:pea :pod . :corn)'
+
+          # Case of a nested list
+          cell = ConsCell.new(ConsCell.new(pea), ConsCell.new(pod))
+          expect(cell.to_s).to eq '((:pea) :pod)'
+        end
       end # context
     end # describe
   end # module

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