mini_kraken 0.2.02 → 0.3.02

data/lib/mini_kraken/rela/fresh.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require_relative '../core/solver_adapter'
+require_relative '../atomic/k_string'
+require_relative 'conj2'
+require_relative 'goal_relation'
+
+module MiniKraken
+  module Rela
+    # A specialized relation that accepts a variable names(s) and a subgoal
+    # as its arguments.
+    class Fresh < GoalRelation
+      include Singleton
+      # Default initialization
+      def initialize
+        super('fresh', 2)
+      end
+
+      def self.build_goal(names, subgoals)
+        var_names = nil
+
+        case names
+          when String
+            var_names = Atomic::KString.new(names)
+
+          when Array
+            var_names = names.map do |nm|
+              nm.is_a?(String) ? Atomic::KString.new(nm) : nm
+            end
+        end
+
+        nested_goal = compose_goals(subgoals)
+        Core::Goal.new(instance, [var_names, nested_goal])
+      end
+
+      def self.compose_goals(subgoals)
+        nested_goal = nil
+
+        case subgoals
+          when Core::Goal
+            nested_goal = subgoals
+
+          when Array
+            goal_array = subgoals
+            loop do
+              conjunctions = []
+              goal_array.each_slice(2) do |uno_duo|
+                if uno_duo.size == 2
+                  conjunctions << Core::Goal.new(Conj2.instance, uno_duo)
+                else
+                  conjunctions << uno_duo[0]
+                end
+              end
+              if conjunctions.size == 1
+                nested_goal = conjunctions[0]
+                break
+              end
+              goal_array = conjunctions
+            end
+          end
+
+        nested_goal
+      end
+
+      # @param actuals [Array<Array<KString>, Core::Term>] A two-elements array
+      # First element is an array of variable names to create.
+      # Second is a sub-goal object
+      # @param ctx [Core::Context] A context object
+      # @return [Fiber<Core::Context>] A Fiber that yields Context objects
+      def solver_for(actuals, ctx)
+        k_names = actuals.shift
+        # require 'debug'
+        subgoal = validated_args(actuals).first
+
+        ctx.enter_scope(Core::Scope.new)
+        if k_names.kind_of?(Atomic::KString)
+          ctx.add_vars(k_names.value)
+        else
+          # ... Array of KString
+          names = k_names.map(&:value)
+          ctx.add_vars(names)
+        end
+
+        # Wrap the subgoal's solver by an adapter
+        orig_solver = subgoal.achieve(ctx)
+        Core::SolverAdapter.new(orig_solver) do |adp, context|
+          # puts "Adaptee #{adp.adaptee}"
+          result = adp.adaptee.resume(context)
+          context.leave_scope if result.nil?
+          result
+        end
+      end
+    end # class
+
+    Fresh.instance.freeze
+  end # module
+end # module

data/lib/mini_kraken/{core → rela}/goal_relation.rb

@@ -1,23 +1,21 @@
 # frozen_string_literal: true
 
-require_relative 'relation'
+require_relative '../core/goal'
+require_relative '../core/relation'
 
 module MiniKraken
-  module Core
+  module Rela
     # A specialization of a relation that accepts only goal(s)
     # as its arguments.
-    class GoalRelation < Relation
-      def arity
-        2
-      end
-
+    class GoalRelation < Core::Relation
       protected
 
+      # Validate that actuals
       def validated_args(actuals)
         actuals.each do |arg|
-          unless arg.kind_of?(Goal)
+          unless arg.kind_of?(Core::Goal)
             prefix = "#{name} expects goal as argument, found a "
-            raise StandardError, prefix + "'#{arg.class}'"
+            raise StandardError, prefix + "'#{arg.class}': #{arg}"
           end
         end
 

data/lib/mini_kraken/rela/unify.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require_relative 'binary_relation'
+
+require_relative '../core/duck_fiber'
+require_relative '../core/log_var_ref'
+require_relative '../atomic/atomic_term'
+require_relative '../composite/all_composite'
+
+
+module MiniKraken
+  module Rela
+    # Corresponds to the '==' relation in canonical miniKanren implementation
+    # in Scheme. Implements the core of the unification algorithm.
+    class Unify < BinaryRelation
+      include Singleton
+
+      symmetric # Unify relation is symmetric ("First Law of ==")
+
+      # Constructor. Initialize the name of the relation
+      def initialize
+        super('unify')
+        freeze
+      end
+
+      # @param actuals [Array<Term>] A two-elements array
+      # @param ctx [Context] A context object
+      # @return [Fiber<Context>] A DuckFiber instance that yields one Context.
+      def solver_for(actuals, ctx)
+        arg1, arg2 = *actuals
+        # context = unification(arg1, arg2, ctx)
+        # Core::DuckFiber.new(-> { context })
+        Core::DuckFiber.new(-> { unification(arg1, arg2, ctx) })
+      end
+
+      # @param arg1 [Term]
+      # @param arg2 [Term]
+      # @param ctx [Context] A context object
+      # @return [Context] The updated context
+      def unification(arg1, arg2, ctx)
+        return ctx.succeeded! if arg1.equal?(arg2)
+        return ctx.failed! if arg1.nil? || arg2.nil?
+
+        new_arg1, new_arg2 = commute_cond(arg1, arg2, ctx)
+        do_unification(new_arg1, new_arg2, ctx)
+      end
+
+      protected
+
+      def do_unification(arg1, arg2, ctx)
+        table = [
+          # cond1                        cond2                          selector
+          [kind_of(Atomic::AtomicTerm), kind_of(Atomic::AtomicTerm),
+            :unify_atomic_terms],
+          [kind_of(Composite::CompositeTerm), kind_of(Atomic::AtomicTerm),
+            :unify_composite_atomic],
+          [kind_of(Composite::CompositeTerm), kind_of(Composite::CompositeTerm),
+            :unify_composite_terms],
+          [kind_of(Core::LogVarRef), kind_of(Atomic::AtomicTerm),
+            :unify_ref_atomic],
+          [kind_of(Core::LogVarRef), kind_of(Composite::CompositeTerm),
+            :unify_ref_composite],
+          [kind_of(Core::LogVarRef), kind_of(Core::LogVarRef),
+            :unify_references]
+        ]
+
+        # require 'debug'
+
+        table.each do |(cond1, cond2, selector)|
+          if cell_success(arg1, cond1, ctx) &&
+             cell_success(arg2, cond2, ctx)
+            return send(selector, arg1, arg2, ctx)
+          end
+        end
+
+        ctx.failed
+      end
+
+=begin
+      # table: Commute
+      # |arg1                | arg2               | arg2.ground? || Commute |
+      # | isa? Atomic        | isa? Atomic        | dont_care    || Yes     |
+      # | isa? Atomic        | isa? CompositeTerm | dont_care    || Yes     |
+      # | isa? Atomic        | isa? LogVarRef   | dont_care    || Yes     |
+      # | isa? CompositeTerm | isa? Atomic        | true         || No      |
+      # | isa? CompositeTerm | isa? CompositeTerm | false        || Yes     |
+      # | isa? CompositeTerm | isa? CompositeTerm | true         || No      |
+      # | isa? CompositeTerm | isa? LogVarRef   | dont_care    || Yes     |
+      # | isa? LogVarRef   | isa? Atomic        | dont_care    || No      |
+      # | isa? LogVarRef   | isa? CompositeTerm | dont_care    || No      |
+      # | isa? LogVarRef   | isa? LogVarRef   | false        || Yes     |
+      # | isa? LogVarRef   | isa? LogVarRef   | true         || No      |
+=end
+
+      def weight_arg(arg, ctx)
+        case arg
+          when Atomic::AtomicTerm
+            1
+          when Composite::CompositeTerm
+            2
+          when Core::LogVarRef
+            # Move unbound argument to the right...
+            arg.unbound?(ctx) ? 3 : 4
+          else
+            raise StandardError
+        end
+      end
+
+      def kind_of(aClass)
+        ->(ar, _) { ar.kind_of?(aClass) }
+      end
+
+      private
+
+      def cell_success(arg, cond, ctx)
+        case cond
+          when Class
+            arg.kind_of?(cond.class)
+          when Proc
+            cond.call(arg, ctx)
+          else
+            raise StandardError
+        end
+      end
+
+      # Unification of two atomic terms
+      # @param arg1 [Atomic::AtomicTerm]
+      # @param arg2 [Atomic::AtomicTerm]
+      # @param ctx [Core::Context] A context object
+      # @return [Core::Context] Updated context
+      def unify_atomic_terms(arg1, arg2, ctx)
+        arg1.eql?(arg2) ? ctx.succeeded! : ctx.failed!
+      end
+
+      # Unification of a composite term with an atomic term
+      # @param _composite [Composite::CompositeTerm]
+      # @param _atomic [Atomic::AtomicTerm]
+      # @param ctx [Core::Context] A context object
+      # @return [Core::Context] a failure Context
+      def unify_composite_atomic(_composite, _atomic, ctx)
+        ctx.failed!
+      end
+
+      # Unification of a composite term with an atomic term
+      # @param arg1 [Composite::CompositeTerm]
+      # @param arg2 [Composite::CompositeTerm]
+      # @param ctx [Core::Context] A context object
+      # @return [Core::Context] Updated context
+      def unify_composite_terms(arg1, arg2, ctx)
+        return ctx.succeeded! if arg1.null? && arg2.null?
+
+        # We do parallel iteration
+        visitor1 = Composite::ConsCellVisitor.df_visitor(arg1)
+        visitor2 = Composite::ConsCellVisitor.df_visitor(arg2)
+        skip_children1 = skip_children2 = false
+
+        loop do
+          # side.. can be: :car, :cdr, :stop
+          side1, cell1 = visitor1.resume(skip_children1)
+          side2, cell2 = visitor2.resume(skip_children2)
+          if side1 != side2
+            ctx.failed
+          elsif side1 == :stop
+            break
+          else
+            # A cell can be: nil, Atomic::AtomicTerm, Composite::ConsCell, LogVarRef
+            case [cell1.class, cell2.class]
+              when [Composite::ConsCell, Composite::ConsCell]
+                skip_children1 = skip_children2 = false
+                ctx.blackboard.succeeded!
+              when [Composite::ConsCell, Core::LogVarRef]
+                skip_children1 = true
+                skip_children2 = false
+                unification(cell1, cell2, ctx)
+              when [Core::LogVarRef, Composite::ConsCell]
+                skip_children1 = false
+                skip_children2 = true
+                do_unification(cell1, cell2, ctx)
+            else
+              skip_children1 = skip_children2 = false
+              unification(cell1, cell2, ctx)
+            end
+          end
+
+          break if ctx.failure?
+        end
+
+        ctx
+      end
+
+      # Unification of a logical variable reference with an atomic term
+      # @param ref [Core::LogVarRef]
+      # @param atomic [Atomic::AtomicTerm]
+      # @param ctx [Core::Context] A context object
+      # @return [Core::Context] Updated context
+      def unify_ref_atomic(ref, atomic, ctx)
+        if ref.unbound?(ctx)
+          ctx.associate(ref, atomic)
+          ctx.succeeded!
+        else
+          assocs = ctx.associations_for(ref.name)
+          first_assoc = assocs.first
+          if first_assoc.kind_of?(Core::Association) &&
+             first_assoc.value.eql?(atomic)
+            # Trying to associate again to the same value is OK
+            ctx.succeeded!
+          else
+            ctx.failed!
+          end
+        end
+      end
+
+      # Unification of a logical variable and a composite
+      # @param ref [Core::LogVarRef]
+      # @param composite [Core::CompositeTerm]
+      # @param ctx [Core::Context] A context object
+      # @return [Core::Context] Updated context
+      def unify_ref_composite(ref, composite, ctx)
+        if ref.unbound?(ctx)
+          ctx.associate(ref, composite)
+        else
+          # Assumption: ref has only one existing association...
+          as = ctx.associations_for(ref.name)
+          first_assoc = as.first.value
+          unification(first_assoc, composite, ctx)
+          return ctx if ctx.failure?
+
+          # The association can be sometimes be redundant...
+          ctx.associate(ref, composite) unless first_assoc.pinned?(ctx)
+        end
+        ctx.succeeded!
+        ctx
+      end
+
+      # Unification of two logical variable references
+      # @param ref1 [Core::LogVarRef]
+      # @param ref2 [Core::LogVarRef]
+      # @param ctx [Core::Context] A context object
+      # @return [Core::Context] Updated context
+      def unify_references(ref1, ref2, ctx)
+        return ctx.succeeded! if ref1.name == ref2.name
+
+        if ref1.unbound?(ctx) || ref2.unbound?(ctx)
+          ctx.fuse([ref1.name, ref2.name])
+          ctx.succeeded!
+        else
+          raise NotImplentedError
+        end
+        # if both refs are fresh, fuse them
+        # if one ref is fresh & the other one isn't then bind fresh one (occurs check)
+        # More cases...
+
+        ctx
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/version.rb

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

data/mini_kraken.gemspec

@@ -40,8 +40,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Dimitri Geshef']
   spec.email         = ['famished.tiger@yahoo.com']
 
-  spec.summary       = 'Implementation of Minikanren language in Ruby. WIP'
-  spec.description   = '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'
 

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,98 @@
+# 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 pinned term' do
+          ctx = double('mock-ctx')
+          expect(subject.pinned?(ctx)).to be_truthy
+        end
+
+        it 'should know that it is not a floating term' do
+          ctx = double('mock-ctx')
+          expect(subject.floating?(ctx)).to be_falsy
+        end
+
+        it 'should know that it is not an unbound term' do
+          ctx = double('mock-ctx')
+          expect(subject.unbound?(ctx)).to be_falsy
+        end
+
+        it 'performs data value comparison' do
+          itself = subject # Renaming as workaround to Rubocop complaint
+          expect(subject == itself).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
+          ctx = double('mock-ctx')
+          expect(subject.quote(ctx)).to eq(subject)
+        end
+
+        it 'should know it has no dependency on variable(s)' do
+          ctx = double('mock-ctx')
+          expect(subject.dependencies(ctx)).to be_empty
+        end
+
+        it 'should dup itself' do
+          substitutions = double('fake-substitutions')
+          duplicate = subject.dup_cond(substitutions)
+          expect(duplicate).to eq(subject) # same value
+          expect(duplicate).not_to be_equal(subject) # different object ids
+        end
+      end # context
+    end # describe
+  end # module
+end # module