mini_kraken 0.1.06 → 0.1.11

data/lib/mini_kraken/core/k_boolean.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'atomic_term'
+
+module MiniKraken
+  module Core
+    # A specialized atomic term that represents an boolean (true/false) value.
+    # in MiniKraken
+    class KBoolean < AtomicTerm
+      # @param aValue [Boolean, Symbol] Ruby representation of boolean value
+      def initialize(aValue)
+        super(validated_value(aValue))
+      end
+
+      private
+
+      def validated_value(aValue)
+        case aValue
+          when true, false
+            aValue
+          when :"#t", '#t'
+            true
+          when :"#f", '#f'
+            false
+          else
+            raise StandardError, "Invalid boolean literal '#{aValue}'"
+        end
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/outcome.rb

@@ -2,36 +2,52 @@
 
 require_relative 'vocabulary'
 
-module MiniKraken
-  module Core
-    class Outcome
-      include Vocabulary # Use mix-in module
+unless MiniKraken::Core.constants(false).include? :Outcome
+  module MiniKraken
+    module Core
+      class Outcome
+        include Vocabulary # Use mix-in module
+
+        # @return [Symbol] One of: :"#s" (success), :"#u" (failure)
+        attr_reader :resultant
+
+        def initialize(aResult, aParent = nil)
+          init_vocabulary(aParent)
+          @resultant = aResult
+        end
 
-      # @return [Symbol] One of: :"#s" (success), :"#u" (failure)
-      attr_reader :resultant
+        def self.failure(aParent = nil)
+          new(:"#u", aParent)
+        end
 
-      def initialize(aResult, aParent = nil)
-        init_vocabulary(aParent)
-        @resultant = aResult
-      end
+        def self.success(aParent = nil)
+          new(:"#s", aParent)
+        end
 
-      def successful?
-        resultant == :"#s"
-      end
+        def successful?
+          resultant == :"#s"
+        end
 
-      def ==(other)
-        are_equal = false
+        def ==(other)
+          are_equal = false
 
-        if resultant == other.resultant && parent == other.parent &&
-           associations == other.associations
-          are_equal = true
+          if resultant == other.resultant && parent == other.parent &&
+             associations == other.associations
+            are_equal = true
+          end
+
+          are_equal
         end
 
-        are_equal
-      end
-    end # class
+        protected
+
+        def introspect
+          ", @resultant=#{resultant}"
+        end
+      end # class
 
-    Failure = Outcome.new(:"#u")
-    BasicSuccess = Outcome.new(:"#s")
+      Failure = Outcome.new(:"#u")
+      BasicSuccess = Outcome.new(:"#s")
+    end # module
   end # module
-end # module
+end # defined

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/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)
@@ -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)
 
@@ -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

@@ -7,38 +7,64 @@ require_relative 'fresh_env'
 module MiniKraken
   module Glue
     class RunStarExpression
+      # @return [FreshEnv] The environment in which run* variables will reside.
       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)
-            result = Core::ConsCell.new(var.quote(outcome))
-          else
-            result = Core::NullList
-            env.associations.freeze
-          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

data/lib/mini_kraken/version.rb

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