mini_kraken 0.2.04 → 0.3.00

data/lib/mini_kraken/core/term.rb

@@ -1,12 +1,23 @@
 # frozen_string_literal: true
 
-require_relative 'goal_arg'
+require_relative 'base_term'
 
 module MiniKraken
   module Core
-    # The generalization of any data value that can be
-    # passed as arugement to a goal.
-    class Term < GoalArg
+    # The generalization of any object that can be:
+    #   - passed as argument to a goal.
+    #   - passed as argument to a MiniKraken procedure
+    #   - contained in a compositer term,
+    #   - associated with a logical variable.
+    class Term < BaseTerm
+      # Abstract method.
+      # Make a copy of self with all the variable reference being
+      # replaced by the corresponding value in the Hash.
+      # @param _substitutions [Hash {String => Term}]
+      # @return [Term]
+      def dup_cond(_substitutions)
+        raise NotImplementedError, "Not implementation for #{self.class}."
+      end
     end # class
   end # module
 end # module

data/lib/mini_kraken/glue/dsl.rb

@@ -1,27 +1,13 @@
 # frozen_string_literal: true
 
 require 'set'
+
+require_relative '../core/all_core'
 require_relative '../atomic/all_atomic'
-require_relative '../core/any_value'
-require_relative '../core/conde'
-require_relative '../core/conj2'
 require_relative '../composite/cons_cell'
-require_relative '../core/def_relation'
-require_relative '../core/disj2'
-require_relative '../core/equals'
-require_relative '../core/fail'
-require_relative '../core/formal_arg'
-require_relative '../core/formal_ref'
-require_relative '../glue/fresh_env'
-require_relative '../glue/fresh_env_factory'
-require_relative '../core/goal_template'
-require_relative '../core/succeed'
-require_relative '../core/tap'
-require_relative '../core/log_var_ref'
-require_relative 'fresh_env'
+require_relative '../rela/all_rela'
 require_relative 'run_star_expression'
 
-
 module MiniKraken
   module Glue
     # The mixin module that implements the methods for the DSL
@@ -37,7 +23,6 @@ module MiniKraken
       end
 
       def conde(*goals)
-        # require 'debug'
         args = goals.map do |goal_maybe|
           if goal_maybe.kind_of?(Array)
             goal_maybe.map { |g| convert(g) }
@@ -46,7 +31,7 @@ module MiniKraken
           end
         end
 
-        Core::Goal.new(Core::Conde.instance, args)
+        Core::Goal.new(Rela::Conde.instance, args)
       end
 
       # conj2 stands for conjunction of two arguments.
@@ -56,7 +41,7 @@ module MiniKraken
       # @param arg2 [Core::Goal]
       # @return [Core::Failure|Core::Success]
       def conj2(arg1, arg2)
-       goal_class.new(Core::Conj2.instance, [convert(arg1), convert(arg2)])
+       goal_class.new(Rela::Conj2.instance, [convert(arg1), convert(arg2)])
       end
 
       def cons(car_item, cdr_item = nil)
@@ -64,27 +49,33 @@ module MiniKraken
         Composite::ConsCell.new(convert(car_item), tail)
       end
 
-      def defrel(relationName, theFormals, &aGoalTemplateExpr)
-        start_defrel
+      def null_list
+        Composite::ConsCell.new(nil, nil)
+      end
 
+      def defrel(relationName, theFormals, aGoalExpr)
         case theFormals
           when String
-            @defrel_formals << theFormals
+            formals = [theFormals]
           when Array
-            @defrel_formals.merge(theFormals)
+            formals = theFormals
         end
+        rela = Rela::DefRelation.new(relationName, aGoalExpr, formals)
+        add_defrel(rela)
 
-        formals = @defrel_formals.map { |name| Core::FormalArg.new(name) }
-        g_template = aGoalTemplateExpr.call
-        result = Core::DefRelation.new(relationName, g_template, formals)
-        add_defrel(result)
+       # start_defrel
 
-        end_defrel
-        result
+        # formals = @defrel_formals.map { |name| Core::FormalArg.new(name) }
+        # g_template = aGoalTemplateExpr.call
+        # result = Core::DefRelation.new(relationName, g_template, formals)
+        # add_defrel(result)
+
+        # end_defrel
+        # result
       end
 
       def disj2(arg1, arg2)
-        goal_class.new(Core::Disj2.instance, [convert(arg1), convert(arg2)])
+        goal_class.new(Rela::Disj2.instance, [convert(arg1), convert(arg2)])
       end
 
       # @return [Core::Fail] A goal that unconditionally fails.
@@ -92,43 +83,26 @@ module MiniKraken
         goal_class.new(Core::Fail.instance, [])
       end
 
-      def equals(arg1, arg2)
-        # require 'debug'
-        goal_class.new(Core::Equals.instance, [convert(arg1), convert(arg2)])
+      def unify(arg1, arg2)
+        goal_class.new(Rela::Unify.instance, [convert(arg1), convert(arg2)])
       end
 
-      def fresh(var_names, goal)
-        vars = nil
-        if @dsl_mode == :defrel
-          if var_names.kind_of?(String)
-            vars = [var_names]
-          else
-            vars = var_names
-          end
-          FreshEnvFactory.new(vars, goal)
-        else
-          if var_names.kind_of?(String) || var_names.kind_of?(Core::LogVarRef)
-            vars = [var_names]
-          else
-            vars = var_names
-          end
-
-          FreshEnv.new(vars, goal)
-        end
+      # @return [Core::Goal]
+      def fresh(names, subgoal)
+        # puts "#{__callee__} #{names}"
+        Rela::Fresh.build_goal(names, subgoal)
       end
 
       def list(*members)
         return null if members.empty?
 
-        head = nil
-        members.reverse_each { |elem| head = Composite::ConsCell.new(convert(elem), head) }
-
-        head
+        converted = members.map { |e| convert(e) }
+        Composite::List.make_list(converted)
       end
 
       # @return [ConsCell] Returns an empty list, that is, a pair whose members are nil.
       def null
-        Composite::ConsCell.new(nil, nil)
+        Composite::ConsCell.null
       end
 
       # @return [Core::Succeed] A goal that unconditionally succeeds.
@@ -136,10 +110,6 @@ 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)
@@ -168,18 +138,14 @@ module MiniKraken
             converted = Atomic::KBoolean.new(anArgument)
           when Atomic::KBoolean, Atomic::KSymbol
             converted = anArgument
-          when Core::FormalRef
-            converted = anArgument
-          when FreshEnv
-            converted = anArgument
           when Core::Goal
             converted = anArgument
-          when Core::GoalTemplate
-            converted = anArgument
           when Core::LogVarRef
             converted = anArgument
           when Composite::ConsCell
             converted = anArgument
+          when NilClass
+            converted = anArgument
           else
             msg = "Internal error: undefined conversion for #{anArgument.class}"
             raise StandardError, msg
@@ -208,7 +174,7 @@ module MiniKraken
       end
 
       def add_defrel(aDefRelation)
-        @defrels = {} unless instance_variable_defined?(:@defrels)
+        @defrels ||= {}
         @defrels[aDefRelation.name] = aDefRelation
       end
 
@@ -219,7 +185,7 @@ module MiniKraken
           result = super(mth, *args)
         rescue NameError
           name = mth.id2name
-          @defrels = {} unless instance_variable_defined?(:@defrels)
+          @defrels ||= {}
           if @defrels.include?(name)
             def_relation = @defrels[name]
             result = Core::Goal.new(def_relation, args.map { |el| convert(el) })

data/lib/mini_kraken/glue/run_star_expression.rb

@@ -1,34 +1,42 @@
 # frozen_string_literal: true
 
-require_relative '../core/any_value'
-require_relative '../composite/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 = Composite::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,146 @@
+# 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
+              result << arg
+
+            when 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