mini_kraken 0.1.07 → 0.1.12

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

@@ -16,6 +16,14 @@ unless MiniKraken::Core.constants(false).include? :Outcome
           @resultant = aResult
         end
 
+        def self.failure(aParent = nil)
+          new(:"#u", aParent)
+        end
+
+        def self.success(aParent = nil)
+          new(:"#s", aParent)
+        end
+
         def successful?
           resultant == :"#s"
         end
@@ -30,6 +38,12 @@ unless MiniKraken::Core.constants(false).include? :Outcome
 
           are_equal
         end
+
+        protected
+
+        def introspect
+          ", @resultant=#{resultant}"
+        end
       end # class
 
       Failure = Outcome.new(:"#u")

data/lib/mini_kraken/core/relation.rb

@@ -16,6 +16,13 @@ module MiniKraken
         @alt_name = alternateName
       end
 
+      # A relation is polyadic when it accepts an arbitrary number of arguments.
+      # Most built-in relation takes a fixed number of arguments (= arity).
+      # @return [Boolean]
+      def polyadic?
+        false
+      end
+
       # Number of arguments for the relation.
       # @return [Integer]
       def arity

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

@@ -67,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
@@ -392,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)
@@ -418,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,21 +7,18 @@ 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
-        next_result = nil
+        result = []
         solver = env.goal.attain(env)
         # require 'debug'
         loop do
@@ -30,24 +27,44 @@ module MiniKraken
           outcome = solver.resume
           break if outcome.nil?
 
-          if result # ... more than one result...
-            if outcome.successful?
-              next_result.append(Core::ConsCell.new(var.quote(outcome)))
-            else
-              next_result.append(Core::NullList)
-            end
-            next_result = next_result.cdr
-          elsif outcome.successful?
-            env.propagate(outcome)
-            result = Core::ConsCell.new(var.quote(outcome))
-            next_result = result
-          else
-            result = Core::NullList
-            next_result = result
-          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.07'
+  VERSION = '0.1.12'
 end

data/spec/core/conde_spec.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/mini_kraken/core/k_symbol'
+require_relative '../../lib/mini_kraken/core/fail'
+require_relative '../../lib/mini_kraken/core/succeed'
+require_relative '../../lib/mini_kraken/core/equals'
+require_relative '../../lib/mini_kraken/core/environment'
+require_relative '../../lib/mini_kraken/core/variable'
+require_relative '../../lib/mini_kraken/core/variable_ref'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/conde'
+
+module MiniKraken
+  module Core
+    describe Conde do
+      subject { Conde.instance }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { Conde.instance }.not_to raise_error
+        end
+
+        it 'should know its name' do
+          expect(subject.name).to eq('conde')
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:bean) { KSymbol.new(:bean) }
+        let(:corn) { KSymbol.new(:corn) }
+        let(:meal) { KSymbol.new(:meal) }
+        let(:oil) { KSymbol.new(:oil) }
+        let(:olive) { KSymbol.new(:olive) }
+        let(:pea) { KSymbol.new(:pea) }
+        let(:red) { KSymbol.new(:red) }
+        let(:split) { KSymbol.new(:split) }
+        let(:fails) { Goal.new(Fail.instance, []) }
+        let(:succeeds) { Goal.new(Succeed.instance, []) }
+        let(:var_q) { Variable.new('q') }
+        let(:var_x) { Variable.new('x') }
+        let(:var_y) { Variable.new('y') }
+        let(:ref_q) { VariableRef.new('q') }
+        let(:ref_x) { VariableRef.new('x') }
+        let(:ref_y) { VariableRef.new('y') }
+        let(:env) do
+          e = Environment.new
+          e.add_var(var_q)
+          e.add_var(var_x)
+          e.add_var(var_y)
+          e
+        end
+
+        it 'should complain when one of its argument is not a goal' do
+          err = StandardError
+          expect { subject.solver_for([succeeds, pea], env) }.to raise_error(err)
+          expect { subject.solver_for([pea, succeeds], env) }.to raise_error(err)
+        end
+
+        it 'should fails if when all goals fail' do
+          solver = subject.solver_for([fails, fails, fails], env)
+          expect(solver.resume).not_to be_successful
+          expect(solver.resume).to be_nil
+        end
+
+        it 'yield success if first argument succeeds' do
+          subgoal = Goal.new(Equals.instance, [olive, ref_q])
+          solver = subject.solver_for([subgoal, fails, fails], env)
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          expect(outcome.associations['q'].first.value).to eq(olive)
+          expect(solver.resume).to be_nil
+        end
+
+        it 'yield success if second argument succeeds' do
+          subgoal = Goal.new(Equals.instance, [oil, ref_q])
+          solver = subject.solver_for([fails, subgoal, fails], env)
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          expect(outcome.associations['q'].first.value).to eq(oil)
+          expect(solver.resume).to be_nil
+        end
+
+        it 'yield success if third argument succeeds' do
+          subgoal = Goal.new(Equals.instance, [oil, ref_q])
+          solver = subject.solver_for([fails, fails, subgoal], env)
+          outcome = solver.resume
+          expect(outcome).to be_successful
+          expect(outcome.associations['q'].first.value).to eq(oil)
+          expect(solver.resume).to be_nil
+        end
+
+        it 'yields three solutions if three goals succeed' do
+          # Covers frame 1:58
+          subgoal1 = Goal.new(Equals.instance, [olive, ref_q])
+          subgoal2 = Goal.new(Equals.instance, [oil, ref_q])
+          subgoal3 = Goal.new(Equals.instance, [pea, ref_q])
+          solver = subject.solver_for([subgoal1, subgoal2, subgoal3, fails], env)
+
+          # First solution
+          outcome1 = solver.resume
+          expect(outcome1).to be_successful
+          expect(outcome1.associations['q'].first.value).to eq(olive)
+
+          # Second solution
+          outcome2 = solver.resume
+          expect(outcome2).to be_successful
+          expect(outcome2.associations['q'].first.value).to eq(oil)
+
+          # Third solution
+          outcome3 = solver.resume
+          expect(outcome3).to be_successful
+          expect(outcome3.associations['q'].first.value).to eq(pea)
+
+          expect(solver.resume).to be_nil
+        end
+
+        it 'also use conjunctions for nested goals' do
+          # Covers frame 1:88
+          subgoal1 = Goal.new(Equals.instance, [split, ref_x])
+          subgoal2 = Goal.new(Equals.instance, [pea, ref_y])
+          combo1 = [subgoal1, subgoal2]
+
+          subgoal3 = Goal.new(Equals.instance, [red, ref_x])
+          subgoal4 = Goal.new(Equals.instance, [bean, ref_y])
+          combo2 = [subgoal3, subgoal4]
+          solver = subject.solver_for([combo1, combo2], env)
+
+          # First solution
+          outcome1 = solver.resume
+          expect(outcome1).to be_successful
+          expect(outcome1.associations['x'].first.value).to eq(split)
+          expect(outcome1.associations['y'].first.value).to eq(pea)
+
+          # Second solution
+          outcome2 = solver.resume
+          expect(outcome2).to be_successful
+          expect(outcome2.associations['x'].first.value).to eq(red)
+          expect(outcome2.associations['y'].first.value).to eq(bean)
+
+          expect(solver.resume).to be_nil
+        end
+      end # context
+    end # describe
+  end # module
+end # module