mini_kraken 0.1.03 → 0.1.08

data/lib/mini_kraken/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MiniKraken
-  VERSION = '0.1.03'.freeze
+  VERSION = '0.1.08'
 end

data/mini_kraken.gemspec

@@ -1,6 +1,8 @@
-lib = File.expand_path("lib", __dir__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "mini_kraken/version"
+require 'mini_kraken/version'
 
 # Implementation module
 module PkgExtending
@@ -10,7 +12,7 @@ module PkgExtending
       '.travis.yml',
       'Gemfile',
       'Rakefile',
-      'CHANGELOG.md',      
+      'CHANGELOG.md',
       'LICENSE.txt',
       'README.md',
       'mini_kraken.gemspec',
@@ -31,25 +33,25 @@ module PkgExtending
 end # module
 
 Gem::Specification.new do |spec|
-  spec.name          = "mini_kraken"
+  spec.name          = 'mini_kraken'
   spec.version       = MiniKraken::VERSION
   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.homepage      = "https://github.com/famished-tiger/mini_kraken"
-  spec.license       = "MIT"
+  spec.homepage      = 'https://github.com/famished-tiger/mini_kraken'
+  spec.license       = 'MIT'
 
   # Specify which files should be added to the gem when it is released.
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-  
+  spec.require_paths = ['lib']
+
   PkgExtending.pkg_files(spec)
-  PkgExtending.pkg_documentation(spec)  
+  PkgExtending.pkg_documentation(spec)
 
-  spec.add_development_dependency "bundler", "~> 2.0"
-  spec.add_development_dependency "rake", "~> 12.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
 end

data/spec/core/association_spec.rb

@@ -10,20 +10,20 @@ require_relative '../../lib/mini_kraken/core/association'
 module MiniKraken
   module Core
     describe Association do
-      let(:pea) {KSymbol.new(:pea) }
+      let(:pea) { KSymbol.new(:pea) }
       subject { Association.new('q', pea) }
 
       context 'Initialization:' do
         it 'should be initialized with a name and a value' do
           expect { Association.new('q', pea) }.not_to raise_error
         end
-        
+
         it 'should be initialized with a variable and a value' do
           expect { Association.new(Variable.new('p'), pea) }.not_to raise_error
-        end        
+        end
 
         it 'should know the variable name' do
-          expect(subject.var_name).to eq('q')
+          expect(subject.i_name).to eq('q')
         end
 
         it 'should know the associated value' do

data/spec/core/association_walker_spec.rb

@@ -58,14 +58,14 @@ module MiniKraken
 
         it 'should return composite when it has ground composite term(s)' do
           env.add_var(var_q)
-          env.add_assoc(Association.new('q', pea))
+          env.add_assoc('q', pea)
           expr1 = cons(pea, cons(pod, cons(ref_q)))
           expect(subject.walk_value(expr1, env)).to eq(expr1)
         end
 
         it 'should return nil when no assocation exists' do
           env.add_var(var_q)
-          env.add_assoc(Association.new('q', pea))
+          env.add_assoc('q', pea)
           env.add_var(var_x)
 
           expect(subject.find_ground(var_x.name, env)).to be_nil
@@ -73,7 +73,7 @@ module MiniKraken
 
         it 'should find an atomic term directly associated' do
           env.add_var(var_q)
-          env.add_assoc(Association.new('q', pea))
+          env.add_assoc('q', pea)
 
           result = subject.find_ground(var_q.name, env)
           expect(result).to eq(pea)
@@ -82,8 +82,8 @@ module MiniKraken
         it 'should find an atomic term directly associated' do
           env.add_var(var_q)
           env.add_var(var_x)
-          env.add_assoc(Association.new('q', ref_x))
-          env.add_assoc(Association.new('x', pea))
+          env.add_assoc('q', ref_x)
+          env.add_assoc('x', pea)
           expect(env['x']).not_to be_nil
 
           result = subject.find_ground(var_q.name, env)
@@ -93,9 +93,9 @@ module MiniKraken
         it 'should cope with cyclic structures' do
           env.add_var(var_q)
           env.add_var(var_x)
-          env.add_assoc(Association.new('q', ref_x))
-          env.add_assoc(Association.new('x', pea))
-          env.add_assoc(Association.new('x', ref_q))
+          env.add_assoc('q', ref_x)
+          env.add_assoc('x', pea)
+          env.add_assoc('x', ref_q)
 
           result = subject.find_ground(var_q.name, env)
           expect(result).to eq(pea)
@@ -107,7 +107,7 @@ module MiniKraken
         it 'should cope with a composite with atomic terms only' do
           env.add_var(var_q)
           expr = cons(pea, cons(pod, cons(pea)))
-          env.add_assoc(Association.new('q', expr))
+          env.add_assoc('q', expr)
 
           result = subject.find_ground(var_q.name, env)
           expect(result).to eq(expr)
@@ -117,7 +117,7 @@ module MiniKraken
           env.add_var(var_q)
           env.add_var(var_x)
           expr = cons(pea, cons(pod, cons(ref_x)))
-          env.add_assoc(Association.new('q', expr))
+          env.add_assoc('q', expr)
 
           result = subject.find_ground(var_q.name, env)
           expect(result).to be_nil
@@ -127,14 +127,13 @@ module MiniKraken
           env.add_var(var_q)
           env.add_var(var_x)
           expr = cons(pea, cons(pod, cons(ref_x)))
-          env.add_assoc(Association.new('q', expr))
-          env.add_assoc(Association.new('x', pod))
+          env.add_assoc('q', expr)
+          env.add_assoc('x', pod)
 
           result = subject.find_ground(var_q.name, env)
           expect(result).to eq(expr)
         end
-=begin
-=end
+
         it 'should categorize a variable without association as free' do
           env.add_var(var_q)
           result = subject.determine_freshness(ref_q, env)
@@ -145,22 +144,24 @@ module MiniKraken
         it 'should categorize a variable related to fresh variable as bound' do
           env.add_var(var_q)
           env.add_var(var_x)
-          env.add_assoc(Association.new('q', ref_x))
+          env.add_assoc('q', ref_x)
 
           result = subject.determine_freshness(ref_q, env)
           expect(result).to be_bound
           expect(result.associated).to eq(ref_x)
         end
 
-        it 'should categorize a variable even in presence of cycle(s)' do
+        it 'should categorize a variable even in presence of fused var(s)' do
           env.add_var(var_q)
           env.add_var(var_x)
-          env.add_assoc(Association.new('q', ref_x))
-          env.add_assoc(Association.new('x', ref_q))
+          env.add_assoc('q', ref_x)
+          env.add_assoc('x', ref_q)
+          # q and x are fused...
 
           result = subject.determine_freshness(ref_q, env)
-          expect(result).to be_bound
-          expect(result.associated).to eq(ref_x)
+          expect(result).to be_fresh
+          expect(var_q.i_name).to eq(var_x.i_name)
+          expect(env.associations).to be_empty
         end
 
         it 'should categorize an atomic term as ground term' do
@@ -176,15 +177,15 @@ module MiniKraken
           expect(result).to be_ground
           expect(result.associated).to eq(composite)
         end
-        
+
         it 'should categorize a composite term as bound term' do
-          # Bound composite: a composite where at least one member is fresh        
-          env.add_var(var_q)       
+          # Bound composite: a composite where at least one member is fresh
+          env.add_var(var_q)
           composite = cons(pea, cons(ref_q))
           result = subject.determine_freshness(composite, env)
           expect(result).to be_bound
           expect(result.associated).to eq(composite)
-        end        
+        end
       end # context
     end # describe
   end # module

data/spec/core/conj2_spec.rb

@@ -0,0 +1,114 @@
+# 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/fail'
+require_relative '../../lib/mini_kraken/core/succeed'
+require_relative '../../lib/mini_kraken/core/equals'
+require_relative '../../lib/mini_kraken/core/environment'
+require_relative '../../lib/mini_kraken/core/variable'
+require_relative '../../lib/mini_kraken/core/variable_ref'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/conj2'
+
+
+module MiniKraken
+  module Core
+    describe Conj2 do
+      subject { Conj2.instance }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { Conj2.instance }.not_to raise_error
+        end
+
+        it 'should know its name' do
+          expect(subject.name).to eq('conj2')
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:env) { Environment.new }
+        let(:pea) { KSymbol.new(:pea) }
+        let(:corn) { KSymbol.new(:corn) }
+        let(:meal) { KSymbol.new(:meal) }
+        let(:fails) { Goal.new(Fail.instance, []) }
+        let(:succeeds) { Goal.new(Succeed.instance, []) }
+        let(:var_q) { Variable.new('q') }
+        let(:ref_q) { VariableRef.new('q') }
+
+        it 'should complain when one of its argument is not a goal' do
+          err = StandardError
+          expect { subject.solver_for([succeeds, pea], env) }.to raise_error(err)
+          expect { subject.solver_for([pea, succeeds], env) }.to raise_error(err)
+        end
+
+        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).to be_nil
+
+          # Fail as second argument
+          solver = subject.solver_for([succeeds, fails], env)
+          expect(solver.resume).not_to be_successful
+          expect(solver.resume).to be_nil
+        end
+
+        it 'yield success if both arguments are succeed goals' do
+          # Covers frame 1-50
+          solver = subject.solver_for([succeeds, succeeds], env)
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          expect(outcome.associations).to be_empty
+          expect(solver.resume).to be_nil
+        end
+
+        it 'should yield success and set associations' do
+          # Covers frame 1-51
+          env.add_var(var_q)
+          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.associations).not_to be_empty
+          expect(outcome.associations['q'].first.value).to eq(corn)
+        end
+
+        it 'should yield fails and set no associations' do
+          # Covers frame 1-52
+          env.add_var(var_q)
+          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.associations).to be_empty
+        end
+
+        it 'should yield fails when sub-goals are incompatible' do
+          # Covers frame 1-53
+          env.add_var(var_q)
+          sub_goal1 = Goal.new(Equals.instance, [corn, ref_q])
+          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.associations).to be_empty
+        end
+
+        it 'should yield success when sub-goals are same and successful' do
+          # Covers frame 1-54
+          env.add_var(var_q)
+          sub_goal1 = Goal.new(Equals.instance, [corn, ref_q])
+          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.associations).not_to be_empty
+          expect(outcome.associations['q'].first.value).to eq(corn)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/cons_cell_spec.rb

@@ -9,8 +9,8 @@ require_relative '../../lib/mini_kraken/core/cons_cell'
 module MiniKraken
   module Core
     describe ConsCell do
-      let(:pea) {KSymbol.new(:pea) }
-      let(:pod) {KSymbol.new(:pod) }
+      let(:pea) { KSymbol.new(:pea) }
+      let(:pod) { KSymbol.new(:pod) }
       subject { ConsCell.new(pea, pod) }
 
       context 'Initialization:' do
@@ -44,7 +44,8 @@ module MiniKraken
       context 'Provided services:' do
         it 'should compare to itself' do
           expect(subject.eql?(subject)).to be_truthy
-          expect(subject == subject).to be_truthy
+          synonym = subject
+          expect(subject == synonym).to be_truthy
         end
 
         it 'should compare to another instance' do
@@ -57,6 +58,14 @@ module MiniKraken
           different = ConsCell.new(pea)
           expect(subject.eql?(different)).to be_falsey
         end
+
+        it 'should append another cons cell' do
+          instance = ConsCell.new(pea)
+          trail = ConsCell.new(pod)
+          instance.append(trail)
+          expect(instance.car).to eq(pea)
+          expect(instance.cdr).to eq(trail)
+        end
       end # context
     end # describe
   end # module

data/spec/core/disj2_spec.rb

@@ -0,0 +1,99 @@
+# 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/fail'
+require_relative '../../lib/mini_kraken/core/succeed'
+require_relative '../../lib/mini_kraken/core/equals'
+require_relative '../../lib/mini_kraken/core/environment'
+require_relative '../../lib/mini_kraken/core/variable'
+require_relative '../../lib/mini_kraken/core/variable_ref'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/disj2'
+
+module MiniKraken
+  module Core
+    describe Disj2 do
+      subject { Disj2.instance }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { Disj2.instance }.not_to raise_error
+        end
+
+        it 'should know its name' do
+          expect(subject.name).to eq('disj2')
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:corn) { KSymbol.new(:corn) }
+        let(:meal) { KSymbol.new(:meal) }
+        let(:oil) { KSymbol.new(:oil) }
+        let(:olive) { KSymbol.new(:olive) }
+        let(:pea) { KSymbol.new(:pea) }
+        let(:fails) { Goal.new(Fail.instance, []) }
+        let(:succeeds) { Goal.new(Succeed.instance, []) }
+        let(:var_q) { Variable.new('q') }
+        let(:ref_q) { VariableRef.new('q') }
+        let(:env) do
+          e = Environment.new
+          e.add_var(var_q)
+          e
+        end
+
+        it 'should complain when one of its argument is not a goal' do
+          err = StandardError
+          expect { subject.solver_for([succeeds, pea], env) }.to raise_error(err)
+          expect { subject.solver_for([pea, succeeds], env) }.to raise_error(err)
+        end
+
+        it 'should fails if both arguments fail' do
+          # Covers frame 1:55
+          solver = subject.solver_for([fails, fails], env)
+          expect(solver.resume).not_to be_successful
+          expect(solver.resume).to be_nil
+        end
+
+        it 'yield success if first argument succeeds' do
+          # Covers frame 1:56
+          subgoal = Goal.new(Equals.instance, [olive, ref_q])
+          solver = subject.solver_for([subgoal, fails], env)
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          expect(outcome.associations['q'].first.value).to eq(olive)
+          expect(solver.resume).to be_nil
+        end
+
+        it 'yield success if second argument succeeds' do
+          # Covers frame 1:57
+          subgoal = Goal.new(Equals.instance, [oil, ref_q])
+          solver = subject.solver_for([fails, subgoal], env)
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          expect(outcome.associations['q'].first.value).to eq(oil)
+          expect(solver.resume).to be_nil
+        end
+
+        it 'yield two solutions if both arguments succeed' do
+          # Covers frame 1:58
+          subgoal1 = Goal.new(Equals.instance, [olive, ref_q])
+          subgoal2 = Goal.new(Equals.instance, [oil, ref_q])
+          solver = subject.solver_for([subgoal1, subgoal2], env)
+
+          # First solution
+          outcome1 = solver.resume
+          expect(outcome1).to be_successful
+          expect(outcome1.associations['q'].first.value).to eq(olive)
+
+          # Second solution
+          outcome2 = solver.resume
+          expect(outcome2).to be_successful
+          expect(outcome2.associations['q'].first.value).to eq(oil)
+          expect(solver.resume).to be_nil
+        end
+      end # context
+    end # describe
+  end # module
+end # module