mini_kraken 0.2.03 → 0.3.03

data/lib/mini_kraken/glue/run_star_expression.rb

@@ -1,34 +1,42 @@
 # frozen_string_literal: true
 
-require_relative '../core/any_value'
-require_relative '../core/cons_cell'
-require_relative 'fresh_env'
+require_relative '../core/context'
+require_relative '../composite/list'
+require_relative '../rela/fresh'
 
 module MiniKraken
   module Glue
     class RunStarExpression
-      # @return [FreshEnv] The environment in which run* variables will reside.
-      attr_reader :env
+      # @return [Core::Context] The context in which run* variables
+      #   will be evaluated.
+      attr_reader :ctx
+
+      # @return [Core::Goal] The main goal to satisfy
+      attr_reader :goal
 
       # @param var_names [String, Array<String>] One variable name or an array of names
-      # @param goal [Core::Goal, Array<Core::Goal>] A single goal or an array of goals to conjunct
-      def initialize(var_names, goal)
-        vnames = var_names.kind_of?(String) ? [var_names] : var_names
-        @env = FreshEnv.new(vnames, goal)
+      # @param aGoal [Core::Goal, Array<Core::Goal>] A single goal or an array of goals to conjunct
+      def initialize(var_names, aGoal)
+        @ctx = Core::Context.new
+        ctx.add_vars(var_names)
+        @goal = Rela::Fresh.compose_goals(aGoal)
       end
 
+      # Run the query, that is, try to find ALL solutions
+      # of the provided qoal.
+      # One solution corresponds to allowed value associated
+      # to the provided logical variable(s).
+      #
       def run
         result = []
-        solver = env.goal.attain(env)
+        solver = goal.achieve(ctx) # A solver == Fiber(-like) yielding Context
         # require 'debug'
+
         loop do
-          env.clear
-          env.clear_rankings
-          outcome = solver.resume
-          break if outcome.nil?
+          outcome = solver.resume(ctx)
+          break if outcome.nil? # No other solution?
 
-          env.propagate(outcome) if result.empty? && outcome.success?
-          result << build_solution(outcome)
+          result << outcome.build_solution.values if outcome.success?
         end
 
         format_solutions(result)
@@ -36,13 +44,6 @@ module MiniKraken
 
       private
 
-      # @return [Array] A vector of assignment for each variable
-      def build_solution(outcome)
-        env.vars.values.map do |var|
-          outcome.success? ? var.quote(outcome) : nil
-        end
-      end
-
       # Transform the solutions into sequence of conscells.
       # @param solutions [Array<Array>] An array of solution.
       # A solution is in itself an array of bindings (one per variable)
@@ -55,14 +56,11 @@ module MiniKraken
       # @param anArray [Array]
       # @param simplify [Boolean]
       def arr2list(anArray, simplify)
-        return anArray[0] if anArray.size == 1 && simplify
-
-        new_tail = nil
-        anArray.reverse_each do |elem|
-          new_tail = Core::ConsCell.new(elem, new_tail)
+        if anArray.size == 1 && simplify
+          anArray[0]
+        else
+          Composite::List.make_list(anArray)
         end
-
-        new_tail
       end
     end # class
   end # module

data/lib/mini_kraken/rela/all_rela.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'conj2'
+require_relative 'disj2'
+require_relative 'fresh'
+require_relative 'unify'
+require_relative 'conde'
+require_relative 'def_relation'

data/lib/mini_kraken/rela/binary_relation.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative '../core/relation'
+
+module MiniKraken
+  module Rela
+    # A binary relation between sets X and Y is a subset of the Cartesian product
+    # X × Y; that is, it is a set of ordered pairs (x, y) consisting of elements
+    # x in X and y in Y.
+    class BinaryRelation < Core::Relation
+      # @param aName [String] Name of the relation.
+      def initialize(aName)
+        super(aName, 2)
+        freeze
+      end
+
+      def self.symmetric
+        define_method :commute_cond do |arg1, arg2, ctx|
+          w1 = weight_arg(arg1, ctx)
+          w2 = weight_arg(arg2, ctx)
+          if w2 > w1
+            [arg2, arg1]
+          else
+            [arg1, arg2]
+          end
+        end
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/rela/conde.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require_relative '../core/context'
+require_relative '../core/duck_fiber'
+require_relative '../core/fail'
+require_relative '../core/goal'
+require_relative 'conj2'
+
+require_relative 'goal_relation'
+
+module MiniKraken
+  module Rela
+    # A polyadic relation (i.e. it can takes an arbitrary number of argumentt)
+    # that behaves as the disjunction of its arguments.
+    # It succeeds if at least one of its goal arguments succeeds.
+    class Conde < GoalRelation
+      include Singleton
+
+      def initialize
+        super('conde', Core::Arity.new(1, '*'))
+      end
+
+      # A relation is polyadic when it accepts an arbitrary number of arguments.
+      # @return [TrueClass]
+      def polyadic?
+        true
+      end
+
+      # @param actuals [Array<Term>] A two-elements array
+      # @param ctx [Core::Context] A vocabulary object
+      # @return [Fiber<Context>] A Fiber that yields Outcomes objects
+      def solver_for(actuals, ctx)
+        args = *validated_args(actuals)
+        Fiber.new { cond(args, ctx) }
+      end
+
+      # Yields [Context, NilClass] result of the disjunction
+      # @param goals [Array<Goal>] Array of goals
+      # @param ctx [Context] A ctxabulary object
+      def cond(goals, ctx)
+        # require 'debug'
+        success = false
+        ctx.place_bt_point
+
+        goals.each do |g|
+          fiber = nil
+
+          case g
+            when Core::Goal
+              fiber = g.achieve(ctx)
+            when Array
+              conjunct = conjunction(g)
+              fiber = conjunct.achieve(ctx)
+            # when Core::ConsCell
+              # goal_array = to_goal_array(g)
+              # conjunct = conjunction(goal_array)
+              # fiber = conjunct.achieve(ctx)
+            else
+              raise NotImplementedError
+          end
+
+          loop do
+            outcome = fiber.resume(ctx)
+            break if outcome.nil?
+
+            if outcome.success?
+              success = true
+              Fiber.yield outcome
+            end
+          end
+
+          ctx.next_alternative
+        end
+
+        Fiber.yield ctx.failed! unless success
+        ctx.retract_bt_point
+        Fiber.yield nil
+      end
+
+      private
+
+      def validated_args(actuals)
+        result = []
+
+        actuals.each do |arg|
+          case arg
+            when Core::Goal, Core::Context
+              result << arg
+
+            when Array
+              result << validated_args(arg)
+
+            else
+              prefix = "#{name} expects goal as argument, found a "
+              raise StandardError, prefix + "'#{arg.class}'"
+          end
+        end
+
+        result
+      end
+
+      # Given an array of goals, build the conjunction of these.
+      def conjunction(goal_array)
+        result = nil
+
+        loop do
+          conjunctions = []
+          goal_array.each_slice(2) do |uno_duo|
+            if uno_duo.size == 2
+              conjunctions << Core::Goal.new(Rela::Conj2.instance, uno_duo)
+            else
+              conjunctions << uno_duo[0]
+            end
+          end
+          if conjunctions.size == 1
+            result = conjunctions[0]
+            break
+          end
+          goal_array = conjunctions
+        end
+
+        result
+      end
+
+      def to_goal_array(aCons)
+        array = []
+        curr_node = aCons
+        loop do
+          array << curr_node.car if curr_node.car.kind_of?(Core::Goal)
+          break unless curr_node.cdr
+          break unless curr_node.car.kind_of?(Core::Goal)
+
+          curr_node = curr_node.cdr
+        end
+
+        array
+      end
+    end # class
+
+    Conde.instance.freeze
+  end # module
+end # module

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,93 @@
+# 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
+
+        compose_goals(aGoalTemplate)
+      end
+
+      def 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
+
+      # 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