porolog 0.0.8 → 1.0.0

data/lib/porolog/rule.rb

@@ -122,39 +122,23 @@ module Porolog
           end
           
           if arguments == :CUT
-            subgoal.calling_goal.terminate!
-            subgoal.calling_goal.log << "TERMINATED by #{subgoal.inspect}"
+            goal.terminate!
+            goal.log << "TERMINATED after #{subgoal.inspect}"
           end
           
           return result
           
         when false
           return false
-      end
-      
-      # -- Unify Subgoal --
-      subsubgoal   = arguments.goal(subgoal)
-      variables    = (subgoal.arguments.variables + subsubgoal.arguments.variables).map(&:to_sym).uniq
-      unified      = true
-      unifications = []
-      
-      variables.each do |variable|
-        name = variable
         
-        unification = unify(name, name, subgoal, subsubgoal)
-        unified   &&= !!unification
-        if unified
-          unifications += unification
-        else
-          #:nocov:
-          subsubgoal.log << "Couldn't unify: #{name.inspect} WITH #{subgoal.myid} AND #{subsubgoal.myid}"
-          break
-          #:nocov:
-        end
+        when nil
+          block.call(subgoal)
+          return true
       end
       
-      # -- Instantiate Unifications --
-      unified &&= instantiate_unifications(unifications) if unified
+      # -- Unify Subsubgoal --
+      subsubgoal = arguments.goal(subgoal)
+      unified    = subsubgoal.inherit_variables(subgoal)
       
       # -- Satisfy Subgoal --
       result = false

data/lib/porolog/scope.rb

@@ -73,7 +73,7 @@ module Porolog
     # @param predicate [Porolog::Predicate] a Predicate to be assigned to the Scope.
     # @return [Porolog::Predicate] the Predicate assigned to the Scope.
     # @raise [NotPredicateError] when provided predicate is not actually a Predicate.
-    def []=(name,predicate)
+    def []=(name, predicate)
       raise NotPredicateError, "#{predicate.inspect} is not a Predicate" unless predicate.is_a?(Predicate)
       @predicates[name.to_sym] = predicate
     end

data/lib/porolog/tail.rb

@@ -23,6 +23,11 @@ module Porolog
       @value = value
     end
     
+    # @return [Symbol] the type of the Tail, which should be :tail.
+    def type
+      :tail
+    end
+    
     # Returns the value of the Tail.
     # The optional arguments are ignored; this is for polymorphic compatibility with Porolog::Value and Porolog::Variable,
     # which are used to prevent inifinite recursion.

data/lib/porolog/value.rb

@@ -54,8 +54,8 @@ module Porolog
     # @param self_index [Integer,Symbol,Array] the index of which this value belongs.
     # @return [String] the inspect of the value in the context of the variables of a goal.
     def inspect_with_instantiations(visited = [], depth = 0, index = nil, self_index = nil)
-      index_str = index      && "[#{index.inspect}]"    || ''
-      prefix    = self_index && "#{self_index.inspect}" || ''
+      index_str = index && "[#{index.inspect}]" || ''
+      prefix    = self_index&.inspect || ''
       
       "#{'  ' * depth}#{prefix}#{inspect}#{index_str}"
     end
@@ -75,7 +75,7 @@ module Porolog
     
     # Responds to all the Value's value methods as well as its own.
     # @return [Boolean] whether the value responds to the method.
-    def respond_to?(method, include_all=false)
+    def respond_to?(method, include_all = false)
       @value.respond_to?(method, include_all) || super
     end
     

data/lib/porolog/variable.rb

@@ -5,7 +5,6 @@
 #       created
 #
 
-
 module Porolog
   
   # A Porolog::Variable is used to hold instantiations during the process of satisfying a goal.
@@ -69,7 +68,7 @@ module Porolog
     # Converts a Variable back to a Symbol.
     # @return [Symbol, nil] the name of the Variable.
     def to_sym
-      @name && @name.to_sym
+      @name&.to_sym
     end
     
     # @return [Symbol] the type of the Variable, which should be :variable.
@@ -135,20 +134,39 @@ module Porolog
       # -- Condense Values --
       result = if values_values.size > 1
         # -- Potentially Multiple Values Found --
+        unifications = []
         if values_values.all?{|value| value.is_a?(Array) }
           # -- All Values Are Arrays --
-          unifications  = []
-          
+          values = values.reject{|value| value == UNKNOWN_ARRAY } if values.size > 2 && values.include?(UNKNOWN_ARRAY)
           values_goals = values.map{|value|
-            value.respond_to?(:goal) && value.goal || value.variables.map(&:goal).first
+            value.respond_to?(:goal) && value.goal || value.variables.map(&:goal).first || values.variables.map(&:goal).first
           }
 
-          merged, unifications = unify_many_arrays(values, values_goals, visited)
+          if values.size > 2
+            merged, unifications = unify_many_arrays(values, values_goals, visited)
+          elsif values.size == 2
+            no_variables = values.map(&:variables).flatten.empty?
+            if no_variables
+              left_value  = values[0].value.value
+              right_value = values[1].value.value
+              if left_value.last == UNKNOWN_TAIL && right_value.first == UNKNOWN_TAIL
+                return [*left_value[0...-1], *right_value[1..-1]]
+              elsif right_value.last == UNKNOWN_TAIL && left_value.first == UNKNOWN_TAIL
+                return [*right_value[0...-1], *left_value[1..-1]]
+              elsif left_value != right_value
+                return nil
+              end
+            end
+            merged, unifications = unify_arrays(*values, *values_goals, visited)
+          else
+            # :nocov: NOT REACHED
+            merged, unifications = values.first, []
+            # :nocov:
+          end
           
           merged.value(visited).to_a
         else
           # -- Not All Values Are Arrays --
-          unifications = []
           values.each_cons(2){|left,right|
             unification = unify(left, right, @goal, @goal, visited)
             if unification && unifications
@@ -158,26 +176,26 @@ module Porolog
             end
           }
           if unifications
-            values.sort_by{|value|
+            values.min_by{|value|
               case value
                 when Variable, Symbol             then  2
                 when UNKNOWN_TAIL, UNKNOWN_ARRAY  then  9
                 else                              0
               end
-            }.first || self
+            } || self
           else
             raise MultipleValuesError, "Multiple values detected for #{inspect}: #{values.inspect}"
           end
         end
       else
         # -- One (or None) Value Found --
-        values.sort_by{|value|
+        values.min_by{|value|
           case value
             when Variable, Symbol             then  2
             when UNKNOWN_TAIL, UNKNOWN_ARRAY  then  9
             else                              0
           end
-        }.first || self
+        } || self
       end
       
       # -- Splat Tail --

data/test/porolog/arguments_test.rb

@@ -504,8 +504,7 @@ describe 'Porolog' do
       end
       
       it 'should call a builtin predicate' do
-        skip 'until StandardPredicates added'
-        
+        builtin :write
         predicate :callwrite
         
         callwrite(:MESSAGE) << [
@@ -522,8 +521,7 @@ describe 'Porolog' do
       end
       
       it 'should pass on instantiations between goals' do
-        skip 'until StandardPredicates added'
-        
+        builtin :write
         predicate :passon, :copy
 
         copy(:A,:A).fact!
@@ -548,8 +546,7 @@ describe 'Porolog' do
       end
       
       it 'should implement simple recursion' do
-        skip 'until StandardPredicates added'
-        
+        builtin :write, :is, :gtr
         predicate :count
         
         count(1) << [
@@ -557,10 +554,12 @@ describe 'Porolog' do
           :CUT
         ]
         count(:N) << [
+          gtr(:N,1),
           write("N = ",:N),
           is(:M,:N){|n| n - 1 },
           write(" M = ",:M,"\n"),
           count(:M),
+          :CUT
         ]
         
         expected_output = [
@@ -586,8 +585,7 @@ describe 'Porolog' do
       end
       
       it 'should solve tower of Hanoi' do
-        skip 'until StandardPredicates added'
-        
+        builtin :gtr, :is, :write
         predicate :move
 
         move(1,:X,:Y,:Z) << [
@@ -629,23 +627,22 @@ describe 'Porolog' do
       end
       
       it 'should solve a peeling off predicate' do
-        skip 'until StandardPredicates added'
-        
-        predicate :size
+        builtin :is
+        predicate :peel
 
-        size([],0).cut_fact!
-        size(:H/:T,:N) << [
-          size(:T,:NT),
+        peel([],0).cut_fact!
+        peel(:H/:T,:N) << [
+          peel(:T,:NT),
           is(:N,:NT){|nt| nt + 1 },
         ]
         
-        solutions = size([],:N).solve
+        solutions = peel([],:N).solve
         
         assert_equal  [
           { N: 0 }
         ],solutions
         
-        solutions = size([13,17,19,23],:N).solve
+        solutions = peel([13,17,19,23],:N).solve
         
         assert_equal  [
           { N: 4 },
@@ -653,10 +650,10 @@ describe 'Porolog' do
       end
       
       it 'should solve tower of Hanoi with list representation' do
-        skip 'until StandardPredicates added and converted to list representation'
         # TODO: convert to list representation
         
-        predicate :tower
+        builtin :gtr, :is, :append, :write
+        predicate :tower, :move
         
         tower(1, :X, :Y, :Z, [[:X,:Z]]).fact!
         tower(:N, :X, :Y, :Z, :S) << [
@@ -668,68 +665,50 @@ describe 'Porolog' do
           append(:S1,  :S2, :S12),
           append(:S12, :S3, :S),
         ]
-        predicate :move
-
-        move(1,:X,:Y,:Z) << [
-          write('Move top disk from ', :X, ' to ', :Y, "\n"),
-        ]
-        move(:N,:X,:Y,:Z) << [
-          gtr(:N,1),
-          is(:M,:N){|n| n - 1 },
-          move(:M,:X,:Z,:Y), 
-          move(1,:X,:Y,:Q), 
-          move(:M,:Z,:Y,:X),
-        ]
-        
-        expected_output = [
-          'Move top disk from left to center',
-          'Move top disk from left to right',
-          'Move top disk from center to right',
-          'Move top disk from left to center',
-          'Move top disk from right to left',
-          'Move top disk from right to center',
-          'Move top disk from left to center',
-          'Move top disk from center to right',
-          'Move top disk from center to left',
-          'Move top disk from right to left',
-          'Move top disk from center to right',
-          'Move top disk from left to center',
-          'Move top disk from left to right',
-          'Move top disk from center to right',
-        ].map{|s| "#{s}\n" }.join
         
         solutions = tower(3, 'left', 'middle', 'right', :moves).solve
         
         expected_solutions = [
           {
             moves: [
-              ['left',   'center'],
               ['left',   'right'],
-              ['center', 'right'],
-              ['left',   'center'],
-              ['right',  'left'],
-              ['right',  'center'],
-              ['left',   'center'],
-              ['center', 'right'],
-              ['center', 'left'],
-              ['right',  'left'],
-              ['center', 'right'],
-              ['left',   'center'],
+              ['left',   'middle'],
+              ['right',  'middle'],
               ['left',   'right'],
-              ['center', 'right'],
+              ['middle', 'left'],
+              ['middle', 'right'],
+              ['left',   'right']
             ]
           }
         ]
         
         assert_equal  expected_solutions, solutions
 
-        assert_output expected_output do
-          solutions = move(4,'left','right','center').solve
-          
-          assert_equal  [
-            {},
-          ],solutions
-        end
+        solutions = tower(4, 'left', 'middle', 'right', :moves).solve
+        
+        expected_solutions = [
+          {
+            moves: [
+              ['left',    'middle'],
+              ['left',    'right'],
+              ['middle',  'right'],
+              ['left',    'middle'],
+              ['right',   'left'],
+              ['right',   'middle'],
+              ['left',    'middle'],
+              ['left',    'right'],
+              ['middle',  'right'],
+              ['middle',  'left'],
+              ['right',   'left'],
+              ['middle',  'right'],
+              ['left',    'middle'],
+              ['left',    'right'],
+              ['middle',  'right']
+            ]
+          }
+        ]
+        
+        assert_equal  expected_solutions, solutions
       end
       
     end

data/test/porolog/core_ext_test.rb

@@ -262,4 +262,29 @@ describe 'Array' do
     
   end
   
+  describe '#clean' do
+    
+    let(:predicate1)  { Predicate.new :generic }
+    let(:arguments1)  { predicate1.arguments(:m,:n) }
+    let(:goal1)       { arguments1.goal }
+    
+    let(:array5)      { [1, 2, goal1[:A], 4, [goal1[:B], 6, 7, goal1[:C]], 9] }
+    let(:array6)      { [1, goal1[:B], 3]/:T }
+    let(:array7)      { [1, goal1[:B], 3]/goal1[:T] }
+    
+    it 'should return simple Arrays as is' do
+      assert_equal    [1, 2, :A, 4, [:B, 6, 7, :C], 9],     array1.clean
+      assert_equal    [],                                   array2.clean
+      assert_equal    [UNKNOWN_TAIL],                       array3.clean
+      assert_equal    [1, :B, 3, UNKNOWN_TAIL],             array4.clean
+    end
+    
+    it 'should return the values of its elements with variables replaced by nil and Tails replaced by UNKNOWN_TAIL' do
+      assert_equal    [1, 2, nil, 4, [nil, 6, 7, nil], 9],  array5.clean
+      assert_equal    [1, nil, 3, UNKNOWN_TAIL],            array6.clean
+      assert_equal    [1, nil, 3, UNKNOWN_TAIL],            array7.clean
+    end
+    
+  end
+  
 end

data/test/porolog/goal_test.rb

@@ -669,23 +669,20 @@ describe 'Porolog' do
       end
       
       it 'should solve a goal recursively' do
-        #:nocov:
-        skip 'until Standard Predicates added'
-        
+        builtin :write
         predicate :recursive
         
         recursive([]) << [:CUT, true]
         recursive(:head/:tail) << [
           write('(',:head,')'),
-          alpha(:tail)
+          recursive(:tail)
         ]
         
         assert_output '(1)(2)(3)(four)(5)(6)(7)' do
-          solutions = alpha([1,2,3,'four',5,6,7]).solve
+          solutions = recursive([1,2,3,'four',5,6,7]).solve
           
           assert_equal    [{}], solutions
         end
-        #:nocov:
       end
       
     end
@@ -706,14 +703,14 @@ describe 'Porolog' do
         goal.arguments.expects(:predicate).with().returns(nil).times(1)
         block.expects(:call).times(0)
         
-        assert_nil      goal.satisfy(&block),   name
+        refute          goal.satisfy(&block),   name
       end
       
       it 'should try to satisfy the predicate with itself' do
         pred.expects(:satisfy).with(goal).returns(nil).times(1)
         block.expects(:call).times(0)
         
-        assert_nil      goal.satisfy(&block),   name
+        refute          goal.satisfy(&block),   name
       end
       
       it 'should call the block when the predicate is satisfied' do
@@ -721,7 +718,7 @@ describe 'Porolog' do
         pred.(3,4).fact!
         pred.(5,6).fact!
         
-        block.expects(:call).times(3)
+        block.expects(:call).returns(true).times(3)
         
         assert          goal.satisfy(&block),   name
       end
@@ -809,6 +806,86 @@ describe 'Porolog' do
       
     end
     
+    describe '#inherit_variables' do
+      
+      it 'should return true for an initial goal' do
+        goal    = new_goal :goal,    :x, :y, :z
+        
+        assert                  goal.inherit_variables
+        assert_Goal_variables   goal, { x: nil, y: nil, z: nil }, [
+          'Goal1.:x',
+          'Goal1.:y',
+          'Goal1.:z',
+        ].join("\n")
+      end
+      
+      it 'should instantiate combined variables of both goals' do
+        goal    = new_goal :goal,    :x, :y, :z
+        subgoal = new_goal :subgoal, :a, :b, :c
+        
+        assert  subgoal.inherit_variables(goal)
+        assert_Goal_variables   goal, { x: nil, y: nil, z: nil, a: nil, b: nil, c: nil }, [
+          'Goal1.:x',
+          '  Goal2.:x',
+          'Goal1.:y',
+          '  Goal2.:y',
+          'Goal1.:z',
+          '  Goal2.:z',
+          'Goal1.:a',
+          '  Goal2.:a',
+          'Goal1.:b',
+          '  Goal2.:b',
+          'Goal1.:c',
+          '  Goal2.:c',
+        ].join("\n")
+        assert_Goal_variables   subgoal, { a: nil, b: nil, c: nil, x: nil, y: nil, z: nil }, [
+          'Goal2.:a',
+          '  Goal1.:a',
+          'Goal2.:b',
+          '  Goal1.:b',
+          'Goal2.:c',
+          '  Goal1.:c',
+          'Goal2.:x',
+          '  Goal1.:x',
+          'Goal2.:y',
+          '  Goal1.:y',
+          'Goal2.:z',
+          '  Goal1.:z',
+        ].join("\n")
+      end
+      
+      it 'should not make any instantiations when variables cannot be unified' do
+        goal    = new_goal :goal,    :x, :y, :z
+        subgoal = new_goal :subgoal, :a, :b, :c
+        
+        goal[:x].instantiate 1
+        subgoal[:x].instantiate 2
+        
+        refute  subgoal.inherit_variables(goal)
+        assert_equal  [
+          'Cannot unify because 1 != 2 (variable != variable)',
+        ], goal.log
+        assert_equal  [
+          'Cannot unify because 1 != 2 (variable != variable)',
+          "Couldn't unify: :x WITH Goal1 AND Goal2"
+        ], subgoal.log
+        assert_Goal_variables   goal, { x: 1, y: nil, z: nil }, [
+          'Goal1.:x',
+          '  Goal1.1',
+          'Goal1.:y',
+          'Goal1.:z',
+        ].join("\n")
+        assert_Goal_variables   subgoal, { a: nil, b: nil, c: nil, x: 2 }, [
+          'Goal2.:a',
+          'Goal2.:b',
+          'Goal2.:c',
+          'Goal2.:x',
+          '  Goal2.2',
+        ].join("\n")
+      end
+      
+    end
+    
   end
   
 end