mini_kraken 0.2.03 → 0.2.04

data/lib/mini_kraken/core/tap.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require_relative 'duck_fiber'
+require_relative 'goal'
+require_relative 'goal_relation'
+require_relative 'outcome'
+
+module MiniKraken
+  module Core
+    class Tap < GoalRelation
+      include Singleton
+
+      def initialize
+        super('tap', nil)
+      end
+
+      def arity
+        1
+      end
+
+      # @param actuals [Array<Term>] A two-elements array
+      # @param anEnv [Vocabulary] A vocabulary object
+      # @return [Fiber<Outcome>] A Fiber that yields Outcomes objects
+      def solver_for(actuals, anEnv)
+        args = *validated_args(actuals)
+        DuckFiber.new(:custom) do
+          outcome = tap(args.first, anEnv)
+          # outcome.prune!
+        end
+      end
+
+      def tap(aGoal, anEnv)
+        require 'debug'
+        f1 = aGoal.attain(anEnv)
+        outcome1 = f1.resume
+        # key = outcome1.associations.keys.first
+        # outcome1.associations['x'] = outcome1.associations[key]
+        # outcome1.associations.delete(key)
+        outcome1
+      end
+    end # class
+
+    Tap.instance.freeze
+  end # module
+end # module

data/lib/mini_kraken/core/vocabulary.rb

@@ -138,12 +138,12 @@ module MiniKraken
       # Check that the provided variable must be fused with the argument.
       # @return [Array<Variable>]
       def detect_fuse(aVariable, aTerm)
-        return [] unless aTerm.kind_of?(VariableRef)
+        return [] unless aTerm.kind_of?(LogVarRef)
 
         assocs = self[aTerm.var_name]
         # Simplified implementation: cope with binary cycles only...
         # TODO: Extend to n-ary (n > 2) cycles
-        assoc_refs = assocs.select { |a| a.value.kind_of?(VariableRef) }
+        assoc_refs = assocs.select { |a| a.value.kind_of?(LogVarRef) }
         return [] if assoc_refs.empty? # No relevant association...
 
         visitees = Set.new
@@ -159,7 +159,7 @@ module MiniKraken
             to_fuse << assc.i_name unless assc.i_name == aVariable.i_name
           end
           other_assocs = self[ref.var_name]
-          other_assoc_refs = other_assocs.select { |a| a.value.kind_of?(VariableRef) }
+          other_assoc_refs = other_assocs.select { |a| a.value.kind_of?(LogVarRef) }
           other_assoc_refs.each do |a|
             to_visit << a unless visitess.include?(a)
           end
@@ -192,7 +192,7 @@ module MiniKraken
             if voc.associations.include?(old_i_name)
               assocs = voc.associations[old_i_name]
               keep_assocs = assocs.reject do |assc|
-                assc.value.kind_of?(VariableRef) && old_names.include?(assc.value.var_name)
+                assc.value.kind_of?(LogVarRef) && old_names.include?(assc.value.var_name)
               end
               unless keep_assocs.empty?
                 keep_assocs.each { |assc| assc.i_name = new_i_name }
@@ -224,14 +224,14 @@ module MiniKraken
         end
       end
 
-      # @param var [Variable, VariableRef] the variable to check.
+      # @param var [Variable, LogVarRef] the variable to check.
       # @return [Boolean]
       def fresh?(var)
         ground_term = ground_value(var)
         ground_term.nil? ? true : false
       end
 
-      # @param var [Variable, VariableRef] variable for which the value to retrieve
+      # @param var [Variable, LogVarRef] variable for which the value to retrieve
       # @return [Term, NilClass]
       def ground_value(var)
         name = var.respond_to?(:var_name) ? var.var_name : var.name
@@ -260,14 +260,14 @@ module MiniKraken
       end
 
       # Determine whether the reference points to a fresh, bound or ground term.
-      # @param aVariableRef [VariableRef]
+      # @param aVariableRef [LogVarRef]
       # @return [Freshness]
       def freshness_ref(aVariableRef)
         walker = AssociationWalker.new
         walker.determine_freshness(aVariableRef, self)
       end
 
-      # @param aVariableRef [VariableRef]
+      # @param aVariableRef [LogVarRef]
       # @return [Term, NilClass]
       def quote_ref(aVariableRef)
         walker = AssociationWalker.new

data/lib/mini_kraken/glue/dsl.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
 require 'set'
+require_relative '../atomic/all_atomic'
 require_relative '../core/any_value'
 require_relative '../core/conde'
 require_relative '../core/conj2'
-require_relative '../core/cons_cell'
+require_relative '../composite/cons_cell'
 require_relative '../core/def_relation'
 require_relative '../core/disj2'
 require_relative '../core/equals'
@@ -14,10 +15,9 @@ 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'
 require_relative '../core/succeed'
-require_relative '../core/variable_ref'
+require_relative '../core/tap'
+require_relative '../core/log_var_ref'
 require_relative 'fresh_env'
 require_relative 'run_star_expression'
 
@@ -30,7 +30,7 @@ module MiniKraken
     module DSL
       # A run* expression tries to find all the solutions
       # that meet the given goal.
-      # @return [Core::ConsCell] A list of solutions
+      # @return [Composite::ConsCell] A list of solutions
       def run_star(var_names, goal)
         program = RunStarExpression.new(var_names, goal)
         program.run
@@ -61,7 +61,7 @@ module MiniKraken
 
       def cons(car_item, cdr_item = nil)
         tail = cdr_item.nil? ? cdr_item : convert(cdr_item)
-        Core::ConsCell.new(convert(car_item), tail)
+        Composite::ConsCell.new(convert(car_item), tail)
       end
 
       def defrel(relationName, theFormals, &aGoalTemplateExpr)
@@ -107,7 +107,7 @@ module MiniKraken
           end
           FreshEnvFactory.new(vars, goal)
         else
-          if var_names.kind_of?(String) || var_names.kind_of?(Core::VariableRef)
+          if var_names.kind_of?(String) || var_names.kind_of?(Core::LogVarRef)
             vars = [var_names]
           else
             vars = var_names
@@ -121,14 +121,14 @@ module MiniKraken
         return null if members.empty?
 
         head = nil
-        members.reverse_each { |elem| head = Core::ConsCell.new(convert(elem), head) }
+        members.reverse_each { |elem| head = Composite::ConsCell.new(convert(elem), head) }
 
         head
       end
 
       # @return [ConsCell] Returns an empty list, that is, a pair whose members are nil.
       def null
-        Core::ConsCell.new(nil, nil)
+        Composite::ConsCell.new(nil, nil)
       end
 
       # @return [Core::Succeed] A goal that unconditionally succeeds.
@@ -136,6 +136,10 @@ module MiniKraken
         goal_class.new(Core::Succeed.instance, [])
       end
 
+      def tap(arg1)
+        goal_class.new(Core::Tap.instance, [convert(arg1)])
+      end
+
       private
 
       def convert(anArgument)
@@ -149,20 +153,20 @@ module MiniKraken
               any_val.instance_variable_set(:@rank, rank)
               converted = any_val
             elsif anArgument.id2name =~ /^"#[ft]"$/
-              converted = Core::KBoolean.new(anArgument)
+              converted = Atomic::KBoolean.new(anArgument)
             else
-              converted = Core::KSymbol.new(anArgument)
+              converted = Atomic::KSymbol.new(anArgument)
             end
           when String
             if anArgument =~ /^#[ft]$/
-              converted = Core::KBoolean.new(anArgument)
+              converted = Atomic::KBoolean.new(anArgument)
             else
               msg = "Internal error: undefined conversion for #{anArgument.class}"
               raise StandardError, msg
             end
           when false, true
-            converted = Core::KBoolean.new(anArgument)
-          when Core::KBoolean
+            converted = Atomic::KBoolean.new(anArgument)
+          when Atomic::KBoolean, Atomic::KSymbol
             converted = anArgument
           when Core::FormalRef
             converted = anArgument
@@ -172,9 +176,9 @@ module MiniKraken
             converted = anArgument
           when Core::GoalTemplate
             converted = anArgument
-          when Core::VariableRef
+          when Core::LogVarRef
             converted = anArgument
-          when Core::ConsCell
+          when Composite::ConsCell
             converted = anArgument
           else
             msg = "Internal error: undefined conversion for #{anArgument.class}"
@@ -224,7 +228,7 @@ module MiniKraken
             if @dsl_mode == :defrel && @defrel_formals.include?(name)
               result = Core::FormalRef.new(name)
             else
-              result = Core::VariableRef.new(name)
+              result = Core::LogVarRef.new(name)
             end
           end
         end

data/lib/mini_kraken/glue/fresh_env.rb

@@ -3,7 +3,7 @@
 require_relative '../core/environment'
 require_relative '../core/conj2'
 require_relative '../core/goal_template'
-require_relative '../core/variable'
+require_relative '../core/log_var'
 
 module MiniKraken
   module Glue
@@ -27,12 +27,17 @@ module MiniKraken
         super()
         @goal = valid_goal(aGoal)
         theNames.each do |nm|
-          var = Core::Variable.new(nm)
+          var = Core::LogVar.new(nm)
           add_var(var)
         end
         @persistent = persistence
       end
 
+      # @return [Relation] The relation associated with the main goal.
+      def relation
+        goal.relation
+      end
+
       # Attempt to achieve the goal given this environment
       # @param aParent [Environment]
       # @return [Fiber<Outcome>] A Fiber object that will generate the results.

data/lib/mini_kraken/glue/fresh_env_factory.rb

@@ -3,7 +3,7 @@
 require_relative '../core/environment'
 require_relative '../core/conj2'
 require_relative '../core/goal_template'
-require_relative '../core/variable'
+require_relative '../core/log_var'
 require_relative 'fresh_env'
 
 module MiniKraken

data/lib/mini_kraken/glue/run_star_expression.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../core/any_value'
-require_relative '../core/cons_cell'
+require_relative '../composite/cons_cell'
 require_relative 'fresh_env'
 
 module MiniKraken
@@ -59,7 +59,7 @@ module MiniKraken
 
         new_tail = nil
         anArray.reverse_each do |elem|
-          new_tail = Core::ConsCell.new(elem, new_tail)
+          new_tail = Composite::ConsCell.new(elem, new_tail)
         end
 
         new_tail

data/lib/mini_kraken/version.rb

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

data/spec/.rubocop.yml

@@ -2,7 +2,7 @@ inherit_from: ../.rubocop.yml
 
 # RSpec expectation lines can be very lenghty
 Layout/LineLength:
-  Max: 99
+  Max: 90
 
 # RSpec contexts can be very lenghty
 Metrics/BlockLength:

data/spec/atomic/atomic_term_spec.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require 'ostruct'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/atomic/atomic_term'
+
+module MiniKraken
+  module Atomic
+    describe AtomicTerm do
+      let(:a_value) { :serenity }
+      let(:other_value) { :fuzziness }
+      subject { AtomicTerm.new(a_value) }
+
+      context 'Initialization:' do
+        it 'should be created with a Ruby datatype instance' do
+          expect { AtomicTerm.new(a_value) }.not_to raise_error
+        end
+
+        it 'knows its value' do
+          expect(subject.value).to eq(a_value)
+        end
+
+        it 'freezes its value' do
+          expect(subject.value).to be_frozen
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should know that it is a ground term' do
+          env = double('mock-env')
+          expect(subject.ground?(env)).to be_truthy
+        end
+
+        it 'should know that it is not a fresh term' do
+          env = double('mock-env')
+          expect(subject.fresh?(env)).to be_falsy
+        end
+
+        it 'should know its freshness' do
+          env = double('mock-env')
+          expect(subject.freshness(env).degree).to eq(:ground)
+        end
+
+        it 'performs data value comparison' do
+          expect(subject == subject).to be_truthy
+          expect(subject == subject.value).to be_truthy
+
+          expect(subject == other_value).to be_falsy
+          expect(subject == AtomicTerm.new(other_value)).to be_falsy
+
+          # Same duck type, same value
+          yet_another = OpenStruct.new(value: a_value)
+          expect(subject == yet_another).to be_truthy
+
+          # Same duck type, different value
+          still_another = OpenStruct.new(value: other_value)
+          expect(subject == still_another).to be_falsy
+        end
+
+        it 'performs type and data value comparison' do
+          expect(subject).to be_eql(subject)
+
+          # Same type, same value
+          other = AtomicTerm.new(a_value)
+          expect(subject).to be_eql(other)
+
+          # Same type, other value
+          another = AtomicTerm.new(other_value)
+          expect(subject).not_to be_eql(another)
+
+          # Different type, same value
+          yet_another = OpenStruct.new(value: other_value)
+          expect(subject).not_to be_eql(yet_another)
+        end
+
+        it 'returns itself when receiving quote message' do
+          env = double('mock-env')
+          expect(subject.quote(env)).to eq(subject)
+        end
+      end # context
+=begin
+      # An atomic term is by definition a ground term: since it doesn't contain
+      # any bound variable (in Prolog sense).
+      # @param _env [Vocabulary]
+      # @return [Freshness]
+      def freshness(_env)
+        Freshness.new(:ground, self)
+      end
+=end
+    end # describe
+  end # module
+end # module

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