mini_kraken 0.2.04 → 0.3.00

data/lib/mini_kraken/rela/conj2.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+require_relative '../core/context'
+require_relative '../core/duck_fiber'
+require_relative 'goal_relation'
+
+module MiniKraken
+  module Rela
+    # The conjunction is a relation that accepts only two goals as its
+    # arguments. It succeeds if and only if both its goal arguments succeeds.
+    class Conj2 < GoalRelation
+      include Singleton
+
+      # Default initialization
+      def initialize
+        super('conj2', 2)
+      end
+
+      # @param actuals [Array<Core::Term>] A two-elements array
+      # @param ctx [Core::Context] A context object
+      # @return [Fiber<Core::Context>] A Fiber that yields Context objects
+      def solver_for(actuals, ctx)
+        g1, g2 = *validated_args(actuals)
+        Fiber.new { conjunction(g1, g2, ctx) }
+      end
+
+      # Yields [Core::Context, NilClass] result of the conjunction
+      # @param g1 [Goal] First goal argument
+      # @param g2 [Goal] Second goal argument
+      # @param ctx [Core::Context] A ctxabulary object
+      def conjunction(g1, g2, ctx)
+        # require 'debug'
+        if g1.relation.kind_of?(Core::Fail) || g2.relation.kind_of?(Core::Fail)
+          Fiber.yield ctx.failed!
+        else
+          outcome1 = outcome2 = nil
+          fiber1 = g1.achieve(ctx)
+
+          loop do
+            outcome1 = fiber1.resume(ctx)
+            break if outcome1.nil?
+
+            if outcome1.success?
+              fiber2 = g2.achieve(ctx)
+              loop do
+                outcome2 = fiber2.resume(ctx)
+                break if outcome2.nil?
+
+                Fiber.yield outcome2
+              end
+            else
+              Fiber.yield outcome1
+            end
+          end
+        end
+
+        Fiber.yield nil
+      end
+    end # class
+
+    Conj2.instance.freeze
+  end # module
+end # module

data/lib/mini_kraken/rela/def_relation.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require_relative '../core/relation'
+require_relative '../core/entry'
+
+module MiniKraken
+  module Rela
+    # A user-defined relation with:
+    # - a user-defined name,
+    # - a ordered list of generic formal arguments, and;
+    # - a goal template expression.
+    class DefRelation < Core::Relation
+      include Core::Entry # Add behaviour of symbol table entries
+
+      # @return [Array<FormalArg>] formal arguments of this DefRelation
+      attr_reader :formals
+
+      # @return [Term] Expression to be fulfilled and parametrized with formals
+      attr_reader :expression
+
+      # @param aName [String] name of def relation
+      # @param anExpression [Term]
+      # @param theFormals [Array<String>]
+      def initialize(aName, anExpression, theFormals)
+        @formals = validated_formals(theFormals)
+        formal_vars = formals.map { |nm| Core::LogVarRef.new(nm) }
+        raw_expression = validated_expression(anExpression)
+        @expression = replace_expression(raw_expression, theFormals, formal_vars)
+        super(aName, formals.size)
+        freeze
+      end
+
+      # @param actuals [Array<Term>] A two-elements array
+      # @param ctx [Context] A Context object
+      # @return [Fiber<Outcome>] A Fiber(-like) instance that yields Outcomes
+      def solver_for(actuals, ctx)
+        actual_expr = replace_expression(expression, formals, actuals)
+        actual_expr.achieve(ctx)
+      end
+
+      private
+
+      def validated_formals(theFormals)
+        # Make the formal names unique, to avoid name collision
+        theFormals.map { |name| "#{name}_#{SecureRandom.uuid}" }
+      end
+
+      def validated_expression(aGoalTemplate)
+        raise StandardError unless aGoalTemplate
+
+        aGoalTemplate
+      end
+
+      # With the given expression, create a new expression where
+      # each allusion to original variable is replaced by the
+      # by its corresponding actual value.
+      def replace_expression(anExpression, original, actual)
+        raw_pairs = original.zip(actual) # [original, actual]
+        anExpression.dup_cond(raw_pairs.to_h)
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/rela/disj2.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+require_relative '../core/context'
+require_relative '../core/duck_fiber'
+require_relative 'goal_relation'
+
+module MiniKraken
+  module Rela
+    # The disjunction is a relation that accepts only goal(s) as its two
+    # arguments. It succeeds if at least one of its goal arguments succeeds.
+    class Disj2 < GoalRelation
+      include Singleton
+
+      # Default initialization
+      def initialize
+        super('disj2', 2)
+      end
+
+      # @param actuals [Array<Core::Term>] A two-elements array
+      # @param ctx [Core::Context] A context object
+      # @return [Fiber<Core::Context>] A Fiber that yields Context objects
+      def solver_for(actuals, ctx)
+        g1, g2 = *validated_args(actuals)
+        Fiber.new { disjunction(g1, g2, ctx) }
+      end
+
+      # Yields [Core::Context, NilClass] result of the disjunction
+      # @param g1 [Goal] First goal argument
+      # @param g2 [Goal] Second goal argument
+      # @param ctx [Core::Context] A ctxabulary object
+      def disjunction(g1, g2, ctx)
+        # require 'debug'
+        if g1.relation.kind_of?(Core::Fail) && g2.relation.kind_of?(Core::Fail)
+          Fiber.yield ctx.failed!
+        else
+          ctx.place_bt_point
+          outcome1 = nil
+          outcome2 = nil
+          f1 = g1.achieve(ctx)
+          loop do
+            outcome1 = f1.resume(ctx)
+            break if outcome1.nil?
+
+            if outcome1.success?
+              Fiber.yield outcome1
+              ctx.next_alternative
+            end
+          end
+          f2 = g2.achieve(ctx)
+          loop do
+            outcome2 = f2.resume(ctx)
+            break if outcome2.nil?
+
+            if outcome2.success?
+              Fiber.yield outcome2
+              ctx.next_alternative
+            end
+          end
+        end
+
+        ctx.retract_bt_point
+        Fiber.yield nil
+      end
+    end # class
+
+    Disj2.instance.freeze
+  end # module
+end # module

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,21 +1,19 @@
 # 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) || arg.kind_of?(Glue::FreshEnv)
+          unless arg.kind_of?(Core::Goal)
             prefix = "#{name} expects goal as argument, found a "
             raise StandardError, prefix + "'#{arg.class}': #{arg}"
           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