mini_kraken 0.2.02 → 0.3.02

data/spec/{core → atomic}/k_boolean_spec.rb

@@ -4,10 +4,10 @@ require_relative '../spec_helper' # Use the RSpec framework
 require 'ostruct'
 
 # Load the class under test
-require_relative '../../lib/mini_kraken/core/k_boolean'
+require_relative '../../lib/mini_kraken/atomic/k_boolean'
 
 module MiniKraken
-  module Core
+  module Atomic
     describe KBoolean do
       subject { KBoolean.new('#t') }
 
@@ -28,12 +28,23 @@ module MiniKraken
         end
 
         it 'should know its value' do
-          expect(subject.value).to eq(true)
-        end
+          other = KBoolean.new(true)
+          expect(other.value).to eq(true)
+
+          other = KBoolean.new('#t')
+          expect(other.value).to eq(true)
+
+          other = KBoolean.new(:"#t")
+          expect(other.value).to eq(true)
+
+          other = KBoolean.new(false)
+          expect(other.value).to eq(false)
+
+          other = KBoolean.new('#f')
+          expect(other.value).to eq(false)
 
-        it 'should know that it is a ground term' do
-          env = double('mock-env')
-          expect(subject.ground?(env)).to be_truthy
+          other = KBoolean.new(:"#f")
+          expect(other.value).to eq(false)
         end
       end # context
 
@@ -43,27 +54,13 @@ module MiniKraken
           other = KBoolean.new(true)
           expect(subject).to be_eql(other)
 
-          other = KBoolean.new(:"#t")
-          expect(subject).to be_eql(other)
-
-          other = KBoolean.new('#t')
-          expect(subject).to be_eql(other)
-
           # Same type, other value
           another = KBoolean.new(false)
           expect(subject).not_to be_eql(another)
 
-          # Same type, other value
-          another = KBoolean.new(:"#f")
-          expect(subject).not_to be_eql(another)
-
           # Same type, other value
           another = KBoolean.new('#f')
           expect(subject).not_to be_eql(another)
-
-          # Different type, same value
-          yet_another = OpenStruct.new(value: true)
-          expect(subject).not_to be_eql(yet_another)
         end
 
         it 'should know whether it has same value than other object' do
@@ -71,27 +68,15 @@ module MiniKraken
           other = KBoolean.new(true)
           expect(subject == other).to be_truthy
 
-          other = KBoolean.new(:"#t")
-          expect(subject == other).to be_truthy
-
-          other = KBoolean.new('#t')
-          expect(subject == other).to be_truthy
-
           # Same type, other value
           another = KBoolean.new(false)
           expect(subject == another).to be_falsy
 
-          another = KBoolean.new(:"#f")
-          expect(subject == another).to be_falsy
-
-          another = KBoolean.new('#f')
-          expect(subject == another).to be_falsy
-
           # Same duck type, same value
           yet_another = OpenStruct.new(value: true)
           expect(subject == yet_another).to be_truthy
 
-          # Different duck type, different value
+          # Same duck type, different value
           still_another = OpenStruct.new(value: false)
           expect(subject == still_another).to be_falsy
 

data/spec/{core → atomic}/k_symbol_spec.rb

@@ -4,10 +4,10 @@ require_relative '../spec_helper' # Use the RSpec framework
 require 'ostruct'
 
 # Load the class under test
-require_relative '../../lib/mini_kraken/core/k_symbol'
+require_relative '../../lib/mini_kraken/atomic/k_symbol'
 
 module MiniKraken
-  module Core
+  module Atomic
     describe KSymbol do
       let(:a_value) { :pea }
       subject { KSymbol.new(a_value) }
@@ -20,11 +20,6 @@ module MiniKraken
         it 'should know its value' do
           expect(subject.value).to eq(a_value)
         end
-
-        it 'should know that it is a ground term' do
-          env = double('mock-env')
-          expect(subject.ground?(env)).to be_truthy
-        end
       end # context
 
       context 'Provided services:' do
@@ -37,7 +32,7 @@ module MiniKraken
           another = KSymbol.new(:pod)
           expect(subject).not_to be_eql(another)
 
-          # Different type, same value
+          # Different duck type, same value
           yet_another = OpenStruct.new(value: :pea)
           expect(subject).not_to be_eql(yet_another)
         end
@@ -51,14 +46,6 @@ module MiniKraken
           another = KSymbol.new(:pod)
           expect(subject == another).to be_falsy
 
-          # Same duck type, same value
-          yet_another = OpenStruct.new(value: :pea)
-          expect(subject == yet_another).to be_truthy
-
-          # Different duck type, different value
-          still_another = OpenStruct.new(value: :pod)
-          expect(subject == still_another).to be_falsy
-
           # Default Ruby representation, same value
           expect(subject == :pea).to be_truthy
 

data/spec/composite/cons_cell_spec.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../support/factory_atomic'
+require_relative '../../lib/mini_kraken/core/context'
+require_relative '../../lib/mini_kraken/core/log_var'
+require_relative '../../lib/mini_kraken/core/log_var_ref'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/composite/cons_cell'
+
+module MiniKraken
+  module Composite
+    describe ConsCell do
+      include MiniKraken::FactoryAtomic # Use mix-in module
+
+      let(:pea) { k_symbol(:pea) }
+      let(:pod) { k_symbol(:pod) }
+      let(:corn) { k_symbol(:corn) }
+      let(:ctx) { Core::Context.new }
+      subject { ConsCell.new(pea, pod) }
+
+      context 'Initialization:' do
+        it 'could be initialized with one argument' do
+          expect { ConsCell.new(pea) }.not_to raise_error
+        end
+
+        it 'could be initialized with a second optional argument' do
+          expect { ConsCell.new(pea, pod) }.not_to raise_error
+        end
+
+        it 'could be initialized as null list' do
+          expect { ConsCell.null }.not_to raise_error
+        end
+
+        it 'should know its car child' do
+          expect(subject.car).to eq(pea)
+        end
+
+        it 'should know its cdr child' do
+          expect(subject.cdr).to eq(pod)
+        end
+
+
+        it 'should know its children' do
+          expect(subject.children).to eq([pea, pod])
+        end
+
+        it 'should know if it is empty (null)' do
+          expect(subject).not_to be_null
+          expect(ConsCell.new(nil, nil)).to be_null
+          expect(ConsCell.null).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
+        it 'should compare to itself' do
+          expect(subject.eql?(subject)).to be_truthy
+          synonym = subject
+          expect(subject == synonym).to be_truthy
+        end
+
+        it 'should compare to another instance' do
+          same = ConsCell.new(pea, pod)
+          expect(subject.eql?(same)).to be_truthy
+
+          different = ConsCell.new(pod, pea)
+          expect(subject.eql?(different)).to be_falsey
+
+          different = ConsCell.new(pea)
+          expect(subject.eql?(different)).to be_falsey
+        end
+
+        it 'should set_car! another cons cell' do
+          instance = ConsCell.new(pea)
+          head = ConsCell.new(pod)
+          instance.set_car!(head)
+          expect(instance.car).to eq(head)
+          expect(instance.cdr).to be_nil
+        end
+
+        it 'should set_cdr! another cons cell' do
+          instance = ConsCell.new(pea)
+          trail = ConsCell.new(pod)
+          instance.set_cdr!(trail)
+          expect(instance.car).to eq(pea)
+          expect(instance.cdr).to eq(trail)
+        end
+
+        it 'should set a member to some term' do
+          instance = ConsCell.null
+          head = ConsCell.new(pea)
+          trail = ConsCell.new(pod)
+          instance.set!(:car, head)
+          instance.set!(:cdr, trail)
+          expect(instance.car).to eq(head)
+          expect(instance.cdr).to eq(trail)
+        end
+
+        it 'should know whether it is pinned or not' do
+          # Case: all pair members are atomic items
+          expect(subject).to be_pinned(ctx)
+
+          # Case: cdr is nil
+          instance = ConsCell.new(pea)
+          expect(instance).to be_pinned(ctx)
+
+          # Case: embedded composite
+          nested = ConsCell.new(ConsCell.new(pod, pea), ConsCell.new(pea))
+          expect(nested).to be_pinned(ctx)
+
+          ctx.add_vars('q')
+          nested.set_cdr!(Core::LogVarRef.new('q'))
+          expect(nested).not_to be_pinned(ctx)
+          expect(nested).to be_floating(ctx)
+
+          ctx.associate('q', ConsCell.new(pea))
+          expect(nested).to be_pinned(ctx)
+        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 one element plus null list
+          cell = ConsCell.new(pea)
+          cell.set_cdr!(ConsCell.null)
+          expect(cell.to_s).to eq '(:pea)'
+
+          # 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
+
+        it 'should know its dependencies' do
+          # Case: no var ref...
+          lst = ConsCell.new(ConsCell.new(pod, pea), ConsCell.new(pea))
+          expect(lst.dependencies(ctx)).to be_empty
+
+          # Case: multiple var refs
+          ctx.add_vars(%w[q x])
+          q_ref = Core::LogVarRef.new('q')
+          x_ref = Core::LogVarRef.new('x')
+          list2 = ConsCell.new(ConsCell.new(q_ref, pea), ConsCell.new(x_ref))
+          expect(list2.dependencies(ctx).size).to eq(2)
+          q_var = ctx.lookup('q')
+          x_var = ctx.lookup('x')
+          predicted = Set.new([q_var.i_name, x_var.i_name])
+          expect(list2.dependencies(ctx)).to eq(predicted)
+        end
+
+        it 'should, as list with atomic terms, provide an expanded copy' do
+          # Case of a list of atomic terms
+          lst = ConsCell.new(ConsCell.new(ConsCell.new(pea), pod))
+          representation = lst.to_s
+
+          copy = lst.expand(ctx, {})
+          expect(copy.to_s).to eq(representation)
+        end
+
+        it 'should, as list with variable refs, provide an expanded copy' do
+          # Case of a list of variable refs
+          ctx.add_vars(['x'])
+          x_ref = Core::LogVarRef.new('x')
+          x_var = ctx.lookup('x')
+          ctx.associate('x', Core::AnyValue.new(0))
+          lst = ConsCell.new(x_ref, ConsCell.new(x_ref))
+          substitutions = {}
+          substitutions[x_var.i_name] = Core::AnyValue.new(0)
+
+          copy = lst.expand(ctx, substitutions)
+          expect(copy.to_s).to eq('(_0 _0)')
+        end
+
+        it 'should provide a duplicate with variable replaced by their value' do
+          q_ref = Core::LogVarRef.new('q')
+          x_ref = Core::LogVarRef.new('x')
+          y_ref = Core::LogVarRef.new('y')
+          substitutions = {
+            'q' => ConsCell.new(pea, ConsCell.new(x_ref, y_ref)),
+            'x' => pod,
+            'y' => corn
+          }
+
+          # Basic case: variable ref points to an atomic value
+          expr = ConsCell.new(pea, x_ref)
+          duplicate = expr.dup_cond(substitutions)
+          expect(duplicate.to_s).to eq('(:pea . :pod)')
+
+          expr = ConsCell.new(pod, ConsCell.new(q_ref, y_ref))
+          duplicate = expr.dup_cond(substitutions)
+          expect(duplicate.car).to eq(pod)
+          expect(duplicate.cdr.car.to_s).to eq('(:pea :pod . :corn)')
+          expect(duplicate.to_s).to eq('(:pod (:pea :pod . :corn) . :corn)')
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/composite/cons_cell_visitor_spec.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../support/factory_atomic'
+require_relative '../../lib/mini_kraken/core/log_var_ref'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/composite/cons_cell_visitor'
+
+module MiniKraken
+  module Composite
+    describe ConsCellVisitor do
+      include MiniKraken::FactoryAtomic # Use mix-in module
+
+      let(:pea) { k_symbol(:pea) }
+      let(:pod) { k_symbol(:pod) }
+      let(:corn) { k_symbol(:corn) }
+      let(:ref_q) { LogVarRef.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 Fiber objects' 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.null
+          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))
+          expect(l_improper.to_s).to eq('(:pea :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
+
+        it 'smurch' do
+          composite = ConsCell.new(ConsCell.new(ConsCell.new(pea)), pod)
+          visitor = subject.df_visitor(composite)
+          expect(visitor.resume).to eq([:car, composite])
+          expect(visitor.resume).to eq([:car, composite.car])
+          expect(visitor.resume).to eq([:car, composite.car.car])
+          expect(visitor.resume).to eq([:car, pea])
+          expect(visitor.resume).to eq([:cdr, nil])
+          expect(visitor.resume).to eq([:cdr, nil])
+          expect(visitor.resume).to eq([:cdr, pod])
+        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(pea)
+          first_cell = ConsCell.new(pea, second_cell)
+          second_cell.set_car!(first_cell)
+
+          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