mini_kraken 0.1.08 → 0.1.13

data/lib/mini_kraken/core/formal_ref.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'base_arg'
+
+module MiniKraken
+  module Core
+    # A formal reference represents the occurrence of a formal argument name in a
+    # goal template argument list.
+    class FormalRef < BaseArg
+      # @return [String]
+      attr_reader :name
+
+      def initialize(aName)
+        @name = validated_name(aName)
+      end
+
+      private
+
+      def validated_name(aName)
+        aName
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/goal.rb

@@ -30,14 +30,20 @@ module MiniKraken
       private
 
       def validated_actuals(args)
-        if args.size != relation.arity
+        if !relation.polyadic? && (args.size != relation.arity)
           err_msg = "Goal has #{args.size} arguments, expected #{relation.arity}"
           raise StandardError, err_msg
         end
 
         prefix = 'Invalid goal argument '
-        args.each do |actl|
-          raise StandardError, prefix + actl.to_s unless actl.kind_of?(GoalArg)
+        args.each do |actual|
+          if actual.kind_of?(GoalArg) || actual.kind_of?(Environment)
+            next
+          elsif actual.kind_of?(Array)
+            validated_actuals(actual)
+          else
+            raise StandardError, prefix + actual.to_s
+          end
         end
 
         args.dup

data/lib/mini_kraken/core/goal_arg.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
+require_relative 'base_arg'
+
 module MiniKraken
   module Core
-    # The generalization of any iem that can be
-    # passed as arugement to a goal.
-    class GoalArg
+    # The generalization of any item that can be
+    # passed as arugement to a goal object
+    class GoalArg < BaseArg
     end # class
   end # module
 end # module

data/lib/mini_kraken/core/goal_template.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative 'base_arg'
+
+module MiniKraken
+  module Core
+    # A meta-goal that is parametrized with generic formal arguments.
+    # The individual goals are instantiated when the formal arguments
+    # are bound to goal arguments
+    class GoalTemplate < BaseArg
+      # @return [Array<BaseArg>}] Arguments of goal template.
+      attr_reader :args
+
+      # @return [Relation] Main relation for the goal template
+      attr_reader :relation
+
+      def initialize(aRelation, theArgs)
+        @relation = validated_relation(aRelation)
+        @args = validated_args(theArgs)
+      end
+
+      # @param formals [Array<FormalArg>] Array of formal arguments
+      # @param actuals [Array<GoalArg>] Array of actual arguments
+      # @return [Goal] instantiate a goal object given the actuals and environment
+      def instantiate(formals, actuals)
+        formals2actuals = {}
+        formals.each_with_index do |frml, i|
+          formals2actuals[frml.name] = actuals[i]
+        end
+
+        do_instantiate(formals2actuals)
+      end
+
+      private
+
+      def validated_relation(aRelation)
+        aRelation
+      end
+
+      def validated_args(theArgs)
+        theArgs
+      end
+
+      def do_instantiate(formals2actuals)
+        goal_args = []
+        args.each do |arg|
+          if arg.kind_of?(FormalRef)
+            goal_args << formals2actuals[arg.name]
+          elsif arg.kind_of?(GoalTemplate)
+            goal_args << arg.send(:do_instantiate, formals2actuals)
+          else
+            goal_args << arg
+          end
+        end
+
+        Goal.new(relation, goal_args)
+      end
+    end # class
+  end # module
+end # module

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/variable.rb

@@ -24,11 +24,17 @@ module MiniKraken
         name != i_name
       end
 
-      def quote(anEnvironment)
-        raise StandardError, "class #{anEnvironment}" unless anEnvironment.kind_of?(Vocabulary)
+      def quote(env)
+        raise StandardError, "class #{env}" unless env.kind_of?(Vocabulary)
 
-        val = anEnvironment.quote_ref(self)
-        val.nil? ? AnyValue.new(name, anEnvironment) : val
+        val = env.quote_ref(self)
+        unless val
+          result = AnyValue.new(name, env, env.names_fused(name))
+        else
+          result = val
+        end
+
+        result
       end
     end # class
   end # module

data/lib/mini_kraken/core/vocabulary.rb

@@ -331,8 +331,9 @@ module MiniKraken
       #   variable name.
       # @param aName [String] User-defined variable name
       def names_fused(aName)
+        # require 'debug'
         var = name2var(aName)
-        return [] unless var.fused?
+        return [] unless var&.fused?
 
         i_name = var.i_name
         names = []
@@ -394,6 +395,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)
@@ -420,6 +433,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.08'
+  VERSION = '0.1.13'
 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