mini_kraken 0.1.05 → 0.1.10

data/lib/mini_kraken/core/succeed.rb

@@ -4,19 +4,23 @@ require 'singleton'
 require_relative 'duck_fiber'
 require_relative 'nullary_relation'
 
-module MiniKraken
-  module Core
-    # A nullary relation that unconditionally always fails.
-    class Succeed < NullaryRelation
-      include Singleton
+unless MiniKraken::Core.constants(false).include? :Succeed
+  module MiniKraken
+    module Core
+      # A nullary relation that unconditionally always fails.
+      class Succeed < NullaryRelation
+        include Singleton
 
-      def initialize
-        super('succeed', '#s')
-      end
+        def initialize
+          super('succeed', '#s')
+        end
 
-      def solver_for(_actuals, _env)
-        DuckFiber.new(:success)
-      end
-    end # class
+        def solver_for(_actuals, _env)
+          DuckFiber.new(:success)
+        end
+      end # class
+
+      Succeed.instance.freeze
+    end # module
   end # module
-end # module
+end # unless

data/lib/mini_kraken/core/term.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
+require_relative 'goal_arg'
+
 module MiniKraken
   module Core
-    # The generalization of data value in MiniKraken
-    class Term
+    # The generalization of any data value that can be
+    # passed as arugement to a goal.
+    class Term < GoalArg
     end # class
   end # module
 end # module

data/lib/mini_kraken/core/variable.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative 'designation'
 require_relative 'any_value'
 require_relative 'vocabulary'
 
@@ -8,32 +9,17 @@ module MiniKraken
     # Representation of a MiniKraken variable.
     # It is a named slot that can be associated with one value.
     class Variable
-      # @return [String] User-defined name of the variable
-      attr_reader :name
+      include Designation # Mixin: Acquire name attribute
 
       # @return [String] Internal variable name used by MiniKraken
       attr_accessor :i_name
 
       # @param aName [String] The name of the variable
       def initialize(aName)
-        @name = valid_name(aName)
+        init_designation(aName)
         @i_name = name.dup
       end
 
-      def fresh?(anEnvironment)
-        anEnvironment.fresh?(self)
-      end
-
-      # @param env [Environment]
-      # @return [Freshness]
-      def freshness(env)
-        env.freshness_ref(self)
-      end
-
-      def ground?(anEnvironment)
-        !fresh?(anEnvironment)
-      end
-
       def fused?
         name != i_name
       end
@@ -44,16 +30,6 @@ module MiniKraken
         val = anEnvironment.quote_ref(self)
         val.nil? ? AnyValue.new(name, anEnvironment) : val
       end
-
-      private
-
-      def valid_name(aName)
-        if aName.empty?
-          raise StandardError, 'Variable name may not be empty.'
-        end
-
-        aName
-      end
     end # class
   end # module
 end # module

data/lib/mini_kraken/core/variable_ref.rb

@@ -8,31 +8,12 @@ module MiniKraken
     # A variable reference represents the occurrence of a variable (name) in a
     # MiniKraken term.
     class VariableRef < Term
-      # @return [String] Name of the variable
-      attr_reader :var_name
+      include Designation # Mixin: Acquire name attribute
+      alias var_name name
 
       # @param aName [String] The name of the variable
       def initialize(aName)
-        @var_name = valid_name(aName)
-      end
-
-      # @param env [Environment]
-      # @return [Boolean]
-      def fresh?(env)
-        env.fresh?(self)
-      end
-
-      # @param env [Environment]
-      # @return [Boolean]
-      def bound?(env)
-        freshness = env.freshness_ref(self)
-        freshness.degree == :bound
-      end
-
-      # @param env [Environment]
-      # @return [Boolean]
-      def ground?(env)
-        !fresh?(env)
+        init_designation(aName)
       end
 
       # @param aValue [Term]
@@ -54,12 +35,6 @@ module MiniKraken
         freshness.associated
       end
 
-      # @param env [Environment]
-      # @return [Freshness]
-      def freshness(env)
-        env.freshness_ref(self)
-      end
-
       # @param env [Environment]
       def quote(env)
         val = env.quote_ref(self)

data/lib/mini_kraken/core/vocabulary.rb

@@ -23,26 +23,28 @@ module MiniKraken
         @rankings = {} unless aParent
       end
 
-      # Return a Fiber object that can iterate over this vocabulary and
+      # Return a Enumerator object that can iterate over this vocabulary and
       # all its direct and indirect parent(s).
-      # @return [Fiber<Vocabulary, NilClass>]
+      # @return [Enumerator<Vocabulary, NilClass>]
       def ancestor_walker
-        Fiber.new do
+        unless @ancestors # Not yet in cache?...
+          @ancestors = []
           relative = self
           while relative
-            Fiber.yield relative
+            @ancestors << relative
             relative = relative.parent
           end
-
-          Fiber.yield nil # nil marks end of iteration...
+          @ancestors << nil # nil marks end of iteration...
         end
+
+        @ancestors.to_enum
       end
 
       def clear_rankings
         walker = ancestor_walker
         orphan = nil
         loop do
-          orphan_temp = walker.resume
+          orphan_temp = walker.next
           break unless orphan_temp
 
           orphan = orphan_temp
@@ -57,7 +59,7 @@ module MiniKraken
         walker = ancestor_walker
         orphan = nil
         loop do
-          orphan_temp = walker.resume
+          orphan_temp = walker.next
           break unless orphan_temp
 
           orphan = orphan_temp
@@ -65,20 +67,22 @@ module MiniKraken
 
         raise StandardError unless orphan
 
+        rank = nil
         if orphan.rankings.include?(aName)
-          orphan.rankings[aName]
+          rank = orphan.rankings[aName]
         else
           other = alternate_names.find do |a_name|
-            orphan.rankings.include?(a_name)
+            rank = orphan.rankings.include?(a_name)
           end
           if other
-            get_rank(other)
+            rank = get_rank(other)
           else
             rank = orphan.rankings.keys.size
             orphan.rankings[aName] = rank
-            rank
           end
         end
+
+        rank
       end
 
       # Record an association between a variable with given user-defined name
@@ -182,7 +186,7 @@ module MiniKraken
           walker = ancestor_walker
 
           loop do
-            voc = walker.resume
+            voc = walker.next
             break unless voc
 
             if voc.associations.include?(old_i_name)
@@ -236,7 +240,7 @@ module MiniKraken
         walker.find_ground(name, self)
       end
 
-      # @param var [CompositeTerm] the composite term to check.
+      # @param val [CompositeTerm] the composite term to check.
       # @return [Boolean]
       def fresh_value?(val)
         walker = AssociationWalker.new
@@ -277,7 +281,7 @@ module MiniKraken
         walker = ancestor_walker
 
         loop do
-          voc = walker.resume
+          voc = walker.next
           if voc
             next unless voc.respond_to?(:vars) && voc.vars.include?(aName)
 
@@ -291,7 +295,7 @@ module MiniKraken
       end
 
       # Return the variable with given internal variable name.
-      # @param aName [String] internal variable name
+      # @param i_name [String] internal variable name
       # @return [Variable]
       def i_name2var(i_name)
         var = nil
@@ -299,7 +303,7 @@ module MiniKraken
         walker = ancestor_walker
 
         loop do
-          voc = walker.resume
+          voc = walker.next
           if voc
             next unless voc.respond_to?(:ivars) && voc.ivars.include?(i_name)
 
@@ -335,7 +339,7 @@ module MiniKraken
         walker = ancestor_walker
 
         loop do
-          voc = walker.resume
+          voc = walker.next
           break unless voc
           next unless voc.respond_to?(:ivars)
 
@@ -358,7 +362,7 @@ module MiniKraken
         walker = ancestor_walker
 
         loop do
-          voc = walker.resume
+          voc = walker.next
           break unless voc
           next unless voc.associations.include?(i_name)
 
@@ -390,6 +394,18 @@ module MiniKraken
         name2var(aVarName) ? true : false
       end
 
+      def inspect
+        result = +"#<#{self.class.name}:#{object_id.to_s(16)} @parent="
+        if parent
+          result << "#<#{parent.class.name}:#{parent.object_id.to_s(16)}>"
+        else
+          result << nil
+        end
+        result << introspect
+        result << '>'
+        result
+      end
+
       protected
 
       def validated_parent(aParent)
@@ -416,6 +432,10 @@ module MiniKraken
           assc
         end
       end
+
+      def introspect
+        ''
+      end
     end # class
   end # module
 end # module

data/lib/mini_kraken/glue/fresh_env.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
 require_relative '../core/environment'
+require_relative '../core/conj2'
 require_relative '../core/variable'
 
 module MiniKraken
   module Glue
+    # A combination of an Environment (= a scope for one or more variables)
+    # and a goal. It quacks like a Goal object: when receiving the attain message,
+    # it attempt to achieve its given goal.
     # (fresh (x) (== 'pea q))
     # Introduces the new variable 'x'
     # Takes a list of names and a goal-like object
@@ -13,11 +17,11 @@ module MiniKraken
       # @return [Goal]
       attr_reader :goal
 
-      # @param theNames [Array<String>]
-      # @param aGoal [Goal]
+      # @param theNames [Array<String>] The variable names
+      # @param aGoal [Goal, Array<Goal>] The goal to achieve or the conjunction of them.
       def initialize(theNames, aGoal)
         super()
-        @goal = aGoal
+        @goal = valid_goal(aGoal)
         theNames.each { |nm| add_var(Core::Variable.new(nm)) }
       end
 
@@ -28,6 +32,44 @@ module MiniKraken
         self.parent = aParent
         goal.attain(self)
       end
+
+      protected
+
+      def introspect
+        +", @vars=[#{vars.keys.join(', ')}]"
+      end
+
+      private
+
+      def valid_goal(aGoal)
+        result = nil
+
+        case aGoal
+          when Core::Goal
+            result = aGoal
+          when FreshEnv
+            result = aGoal
+          when Array # an Array of Goal?..
+            goal_array = aGoal
+            loop do
+              conjunctions = []
+              goal_array.each_slice(2) do |uno_duo|
+                if uno_duo.size == 2
+                  conjunctions << Core::Goal.new(Core::Conj2.instance, uno_duo)
+                else
+                  conjunctions << uno_duo[0]
+                end
+              end
+              if conjunctions.size == 1
+                result = conjunctions[0]
+                break
+              end
+              goal_array = conjunctions
+            end
+        end
+
+        result
+      end
     end # class
   end # module
 end # module

data/lib/mini_kraken/glue/run_star_expression.rb

@@ -9,36 +9,61 @@ module MiniKraken
     class RunStarExpression
       attr_reader :env
 
-      # @param var_name [String]
-      # @param goal [Core::Goal]
-      def initialize(var_name, goal)
-        @env = FreshEnv.new([var_name], goal)
-      end
-
-      def var
-        env.vars.values.first
+      # @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)
       end
 
       def run
-        result = nil
+        result = []
         solver = env.goal.attain(env)
         # require 'debug'
         loop do
+          env.clear
+          env.clear_rankings
           outcome = solver.resume
           break if outcome.nil?
 
-          env.clear
-          if result # ... more than one result...
-          elsif outcome.successful?
-            env.propagate(outcome)
-            # require 'debug'
-            result = Core::ConsCell.new(var.quote(outcome))
-          else
-            result = Core::NullList
-          end
+          env.propagate(outcome) if result.empty? && outcome.successful?
+          result << build_solution(outcome)
+        end
+
+        format_solutions(result)
+      end
+
+      private
+
+      # @return [Array] A vector of assignment for each variable
+      def build_solution(outcome)
+        sol = env.vars.values.map do |var|
+          outcome.successful? ? var.quote(outcome) : nil
+        end
+
+        sol
+      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)
+      def format_solutions(solutions)
+        solutions_as_list = solutions.map { |sol| arr2list(sol, true) }
+        arr2list(solutions_as_list, false)
+      end
+
+      # Utility method. Transform an array into a ConsCell-based list.
+      # @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)
         end
 
-        result
+        new_tail
       end
     end # class
   end # module