porolog 0.0.8 → 1.0.0

data/lib/porolog/arguments.rb

@@ -20,7 +20,7 @@ module Porolog
   #   The actual arguments.
   class Arguments
     
-    attr_reader :predicate, :arguments
+    attr_reader :predicate, :arguments, :block
     
     # Unregisters all Arguments
     # @return [true]
@@ -34,9 +34,10 @@ module Porolog
     # Creates a new Arguments for a Predicate
     # @param predicate [Porolog::Predicate] the Predicate for which these are the arguments
     # @param arguments [Array<Object>] the actual arguments
-    def initialize(predicate, arguments)
+    def initialize(predicate, arguments, &block)
       @predicate = predicate
       @arguments = arguments
+      @block     = block
       @@arguments << self
     end
     
@@ -54,7 +55,8 @@ module Porolog
     
     # @return [String] pretty representation
     def inspect
-      "#{@predicate && @predicate.name}(#{@arguments && @arguments.map(&:inspect).join(',')})"
+      block_inspect = block.nil? ? '' : "{#{block.inspect}}"
+      "#{@predicate&.name}(#{@arguments&.map(&:inspect).join(',')})#{block_inspect}"
     end
     
     # Creates a fact rule that states that these arguments satisfy the Predicate.
@@ -103,9 +105,7 @@ module Porolog
     
     # @return [Array<Symbol>] the variables contained in the arguments
     def variables
-      @arguments.map{|argument|
-        argument.variables
-      }.flatten.uniq
+      @arguments.map(&:variables).flatten.uniq
     end
     
     # Creates a Goal for solving this Arguments for the Predicate
@@ -120,7 +120,7 @@ module Porolog
     # @return [Array<Hash{Symbol => Object}>] the solutions found (memoized)
     def solutions(max_solutions = nil)
       @solutions ||= solve(max_solutions)
-      @solutions
+      max_solutions && @solutions[0...max_solutions] || @solutions
     end
     
     # Solves the Arguments
@@ -132,6 +132,7 @@ module Porolog
     
     # Extracts solution values.
     # @param variables [Symbol, Array<Symbol>] variable or variables
+    # @param max_solutions [Integer] the maximum number of solutions to find (nil means find all)
     # @return [Array<Object>] all the values for the variables given
     # @example
     #   predicate :treasure_at
@@ -140,9 +141,9 @@ module Porolog
     #   xs = arguments.solve_for(:X)
     #   ys = arguments.solve_for(:Y)
     #   coords = xs.zip(ys)
-    def solve_for(*variables)
+    def solve_for(*variables, max_solutions: nil)
       variables = [*variables]
-      solutions.map{|solution|
+      solutions(max_solutions).map{|solution|
         values = variables.map{|variable| solution[variable] }
         if values.size == 1
           values.first
@@ -154,14 +155,14 @@ module Porolog
     
     # @return [Boolean] whether any solutions were found
     def valid?
-      !solutions.empty?
+      !solutions(1).empty?
     end
     
     # Duplicates the Arguments in the context of the given goal
     # @param goal [Porolog::Goal] the destination goal
     # @return [Porolog::Arguments] the duplicated Arguments
     def dup(goal)
-      self.class.new @predicate, goal.variablise(arguments)
+      self.class.new @predicate, goal.variablise(arguments), &@block
     end
     
     # @param other [Porolog::Arguments] arguments for comparison

data/lib/porolog/core_ext.rb

@@ -14,7 +14,7 @@ class Object
   # A convenience method for testing/debugging.
   # @return [String] the equivalent of inspect.
   def myid
-    self.inspect
+    inspect
   end
   
   # @return [Array] embedded variables (for an Object, should be none).
@@ -58,7 +58,7 @@ class Symbol
   # A convenience method for testing/debugging.
   # @return [String] the equivalent of inspect.
   def myid
-    self.inspect
+    inspect
   end
   
   # @return [Array] embedded variables (for a Symbol, should be itself).
@@ -89,18 +89,20 @@ class Array
   end
   
   # @return [Array] the values of its elements.
-  def value(*args)
-    map{|element|
+  def value(visited = [])
+    return self if visited.include?(self)
+    visited = visited + [self]
+    flat_map{|element|
       if element.is_a?(Tail)
-        tail = element.value(*args)
+        tail = element.value(visited)
         if tail.is_a?(Array)
           tail
         elsif tail.is_a?(Variable) || tail.is_a?(Value)
-          tail = tail.value(*args)
+          tail = tail.value(visited)
           if tail.is_a?(Array)
             tail
           elsif tail.is_a?(Variable) || tail.is_a?(Value)
-            tail = tail.goal.variablise(tail.value(*args))
+            tail = tail.goal.variablise(tail.value(visited))
             if tail.is_a?(Array)
               tail
             else
@@ -113,9 +115,25 @@ class Array
           [element]
         end
       else
-        [element.value(*args)]
+        [element.value(visited)]
       end
-    }.flatten(1)
+    }
+  end
+  
+  # Removes Porolog processing objects.
+  # @return [Array] the values of its elements with variables replaced by nil and Tails replaced by UNKNOWN_TAIL.
+  def clean
+    value.map{|element|
+      if element.is_a?(Array)
+        element.clean
+      elsif element.is_a?(Tail)
+        UNKNOWN_TAIL
+      elsif element.is_a?(Variable)
+        nil
+      else
+        element.value
+      end
+    }
   end
   
   # @return [Symbol] the type of the object (for an Array, should be :array)

data/lib/porolog/error.rb

@@ -15,5 +15,8 @@ module Porolog
   
   # Error indicating that a Goal is needed but could not be found.
   class NoGoalError  < PorologError ; end
+  
+  # Error indicating that a Variable is needed but was not provided.
+  class NonVariableError  < PorologError ; end
 
 end

data/lib/porolog/goal.rb

@@ -39,10 +39,16 @@ module Porolog
       @@goals ||= []
       goals = @@goals
       @@goals = []
+      @@goal_count = 0
       goals.map(&:deleted?)
       true
     end
     
+    # @return [Integer] the number of goals created
+    def self.goal_count
+      @@goal_count
+    end
+    
     reset
     
     attr_accessor :calling_goal, :arguments, :index, :result, :description, :log
@@ -52,6 +58,7 @@ module Porolog
     # @param calling_goal [Porolog::Goal] the parent Goal if this Goal is a subgoal.
     def initialize(arguments, calling_goal = nil)
       @@goals << self
+      @@goal_count += 1
       
       @arguments    = arguments
       @terminate    = false
@@ -124,12 +131,12 @@ module Porolog
     def check_deleted
       return false if @@goals.include?(self)
       
-      @variables.delete_if do |name,variable|
+      @variables.delete_if do |_name,variable|
         variable.remove
         true
       end
       
-      @values.delete_if do |name,value|
+      @values.delete_if do |_name,value|
         value.remove
         true
       end
@@ -170,7 +177,7 @@ module Porolog
         when NilClass
           nil
         else
-          if object == UNKNOWN_TAIL || object == UNKNOWN_ARRAY
+          if [UNKNOWN_TAIL, UNKNOWN_ARRAY].include?(object)
             object
           else
             value(object)
@@ -178,17 +185,16 @@ module Porolog
       end
     end
     
-    alias_method :[], :variablise
+    alias [] variablise
     
     # @return [Hash{Symbol => Object}] the Variables and their current values of this Goal
     def variables
       @variables.keys.each_with_object({}){|variable,variable_list|
-        value = value_of(variable)
-        value = value.value if value.is_a?(Value)
+        value = value_of(variable).value.value
         if value.is_a?(Variable)
           variable_list[variable] = nil
-        elsif value.is_a?(Value) || value.is_a?(Array)
-          variable_list[variable] = value.value
+        elsif value.is_a?(Array)
+          variable_list[variable] = value.clean
         else
           variable_list[variable] = value
         end
@@ -198,15 +204,13 @@ module Porolog
     # A convenience method for testing/debugging.
     # @return [String] a tree representation of all the instantiations of this goal's variables.
     def inspect_variables
-      @variables.map{|name,variable|
-        variable.inspect_with_instantiations
-      }.join("\n")
+      @variables.values.map(&:inspect_with_instantiations).join("\n")
     end
     
     # A convenience method for testing/debugging.
     # @return [Array<Object>] the values instantiated for this goal.
     def values
-      @values.map{|name,value| value.value }
+      @values.values.map(&:value)
     end
     
     # Finds or tries to create a variable in the goal (as much as possible) otherwise passes the parameter back.
@@ -267,7 +271,9 @@ module Porolog
       
       predicate = @arguments.predicate
       
-      predicate && predicate.satisfy(self) do |goal|
+      predicate&.satisfy(self) do |goal|
+        # TODO: Refactor to overrideable method (or another solution, say a lambda)
+        
         @solutions << variables
         @log << "SOLUTION: #{variables}"
         @log << goal.ancestry
@@ -288,9 +294,12 @@ module Porolog
       
       predicate = @arguments.predicate
       
-      predicate && predicate.satisfy(self) do |subgoal|
-        block.call(subgoal)
+      satisfied = false
+      predicate&.satisfy(self) do |subgoal|
+        subgoal_satisfied = block.call(subgoal)
+        satisfied ||= subgoal_satisfied
       end
+      satisfied
     end
     
     # Instantiates a Variable to another Variable or Value, for this Goal.
@@ -310,6 +319,39 @@ module Porolog
       variable.instantiate(other)
     end
     
+    # Inherits variables and their instantiations from another goal.
+    # @param other_goal [Porolog::Goal,nil] the Goal to inherit variables from.
+    # @return [Boolean] whether the variables could be inherited (unified).
+    def inherit_variables(other_goal = @calling_goal)
+      return true unless other_goal
+      
+      unified      = true
+      unifications = []
+      variables    = (
+        other_goal.arguments.variables +
+        other_goal.variables.keys +
+        self.arguments.variables
+      ).map(&:to_sym).uniq
+      
+      variables.each do |variable|
+        name = variable
+        
+        unification = unify(name, name, other_goal, self)
+        unified   &&= !!unification
+        if unified
+          unifications += unification
+        else
+          #:nocov:
+          self.log << "Couldn't unify: #{name.inspect} WITH #{other_goal.myid} AND #{self.myid}"
+          break
+          #:nocov:
+        end
+      end
+      unified &&= instantiate_unifications(unifications) if unified
+      
+      unified
+    end
+    
   end
   
 end

data/lib/porolog/instantiation.rb

@@ -121,7 +121,7 @@ module Porolog
       return nil unless variables.include?(variable)
       
       other_variable = (variables - [variable]).first
-      other_variable && other_variable.goal
+      other_variable&.goal
     end
     
     # @return [Array<Porolog::Goal>] the Goals of the Variables of the Instantiation.
@@ -139,10 +139,10 @@ module Porolog
     def values(visited = [])
       return [] if visited.include?(self)
       
-      vv1 = values_for(@variable1, visited)
-      vv2 = values_for(@variable2, visited)
+      values_for_variable1 = values_for(@variable1, visited)
+      values_for_variable2 = values_for(@variable2, visited)
       
-      (vv1 + vv2).uniq
+      (values_for_variable1 + values_for_variable2).uniq
     end
     
     # @param value [Object] the provided value.
@@ -174,7 +174,21 @@ module Porolog
         
         when Symbol
           value_value = value.value(visited)
-          if value_value.respond_to?(index)
+          if index == :flathead
+            # value_value = [..., 4, 5, 6]
+            if value_value.first == UNKNOWN_TAIL
+              UNKNOWN_ARRAY
+            else
+              nil
+            end
+          elsif index == :flattail
+            # value_value = [1, 2, 3, ...]
+            if value_value.first == UNKNOWN_TAIL
+              nil
+            elsif value_value.last == UNKNOWN_TAIL
+              UNKNOWN_ARRAY
+            end
+          elsif value_value.respond_to?(index)
             value_value.send(index)
           else
             value
@@ -204,6 +218,22 @@ module Porolog
       visited = visited + [self]
       
       if variable == @variable1
+        if @index1 == :flathead
+          flathead = value_at_index(value_indexed(@variable2.value(visited), @index2, visited), @index1).value.value
+          if flathead
+            return [[*flathead]]
+          else
+            return []
+          end
+        end
+        if @index1 == :flattail
+          flattail = value_at_index(value_indexed(@variable2.value(visited), @index2, visited), @index1).value.value
+          if flattail
+            return [[UNKNOWN_TAIL, *flattail]]
+          else
+            return []
+          end
+        end
         if @index1
           [value_at_index(value_indexed(@variable2.value(visited), @index2, visited), @index1)]
         else
@@ -214,6 +244,22 @@ module Porolog
           end
         end
       elsif variable == @variable2
+        if @index2 == :flathead
+          flathead = value_at_index(value_indexed(@variable1.value(visited), @index1, visited), @index2).value.value
+          if flathead
+            return [[*flathead]]
+          else
+            return []
+          end
+        end
+        if @index2 == :flattail
+          flattail = value_at_index(value_indexed(@variable1.value(visited), @index1, visited), @index2).value.value
+          if flattail
+            return [[UNKNOWN_TAIL, *flattail]]
+          else
+            return []
+          end
+        end
         if @index2
           [value_at_index(value_indexed(@variable1.value(visited), @index1, visited), @index2)]
         else
@@ -241,10 +287,14 @@ module Porolog
         
         when Symbol
           case index
+            when :flathead
+              [*value, UNKNOWN_TAIL]
             when :head
               [value, UNKNOWN_TAIL]
             when :tail
               [nil, *value]
+            when :flattail
+              value
             else
               raise UnhandledIndexError, "Unhandled index: #{index.inspect} for #{value.inspect}"
           end
@@ -253,10 +303,6 @@ module Porolog
           if index.empty?
             [nil, *value]
           else
-            #result                 = []
-            #result[0..index.first] = value
-            #result
-            #[*([*value][0..index.first]), UNKNOWN_TAIL]
             [value, UNKNOWN_TAIL]
           end
         

data/lib/porolog/predicate.rb

@@ -28,6 +28,10 @@ module Porolog
     
     attr_reader :name, :rules
     
+    # A unique value used to verify instantiations.
+    UNIQUE_VALUE = Object.new.freeze
+    private_constant :UNIQUE_VALUE
+    
     # Returns the current scope, or sets the current scope if a paramter is provided
     # (creating the new scope if necessary).
     # @param scope_name [Object] the name (or otherwise object) used to register a scope.
@@ -67,9 +71,10 @@ module Porolog
     # Initializes a Porolog::Predicate and registers it by its name.
     # @param name [#to_sym] the input object to read from
     # @param scope_name the name of the scope in which to register the Predicate; if omitted, defaults to the name of the current scope
-    def initialize(name, scope_name = Predicate.scope.name)
-      @name  = name.to_sym
-      @rules = []
+    def initialize(name, scope_name = Predicate.scope.name, builtin: false)
+      @name    = name.to_sym
+      @rules   = []
+      @builtin = builtin
       
       raise NameError, "Cannot name a predicate 'predicate'" if @name == :predicate
       
@@ -80,8 +85,7 @@ module Porolog
     # Creates a new Predicate, or returns an existing Predicate if one already exists with the given name in the current scope.
     # @return [Porolog::Predicate] a new or existing Predicate.
     def self.new(*args)
-      name, _ = *args
-      scope[name.to_sym] || super
+      scope[args.first.to_sym] || super
     end
     
     # Create Arguments for the Predicate.
@@ -90,14 +94,14 @@ module Porolog
     # for
     #     p.arguments(x,y,z)
     # @return [Porolog::Arguments] Arguments of the Predicate with the given arguments.
-    def call(*args)
-      Arguments.new(self,args)
+    def call(*args, &block)
+      Arguments.new(self, args, &block)
     end
     
     # Create Arguments for the Predicate.
     # @return [Porolog::Arguments] Arguments of the Predicate with the given arguments.
-    def arguments(*args)
-      Arguments.new(self,args)
+    def arguments(*args, &block)
+      Arguments.new(self, args, &block)
     end
     
     # Add a Rule to the Predicate.
@@ -120,31 +124,53 @@ module Porolog
       end
     end
     
-    # Return a builtin Predicate based on its key.
-    # @param key [Symbol] the name (or otherwise object) used to register a scope.
-    # @return [Porolog::Predicate] a Predicate with the next id based on the key.
-    def self.builtin(key)
-      @builtin_predicate_ids[key] ||= 0
-      @builtin_predicate_ids[key]  += 1
-      
-      self.new("_#{key}_#{@builtin_predicate_ids[key]}")
-    end
-    
     # Satisfy the Predicate within the supplied Goal.
     # Satisfy of each rule of the Predicate is called with the Goal and success block.
     # @param goal [Porolog::Goal] the Goal within which to satisfy the Predicate.
     # @param block [Proc] the block to be called each time a Rule of the Predicate is satisfied.
     # @return [Boolean] whether any Rule was satisfied.
     def satisfy(goal, &block)
-      satisfied = false
-      @rules.each do |rule|
-        rule.satisfy(goal) do |subgoal|
-          satisfied = true
-          block.call(subgoal)
+      if builtin?
+        satisfy_builtin(goal, &block)
+      else
+        satisfied = false
+        @rules.each do |rule|
+          rule.satisfy(goal) do |subgoal|
+            satisfied = true
+            block.call(subgoal)
+          end
+          break if goal.terminated?
         end
-        break if goal.terminated?
+        satisfied
       end
-      satisfied
+    end
+    
+    # @return [Boolean] whether the Predicate is a builtin predicate.
+    def builtin?
+      @builtin
+    end
+    
+    # Satisfy the builtin Predicate within the supplied Goal.
+    # Call the builtin Predicate method with the Goal and success block.
+    # The arguments and block are extracted from the Goal's Arguments.
+    # @param goal [Porolog::Goal] the Goal within which to satisfy the Predicate.
+    # @param block [Proc] the block to be called each time a Rule of the Predicate is satisfied.
+    # @return [Boolean] whether any Rule was satisfied.
+    def satisfy_builtin(goal, &block)
+      predicate = goal.arguments.predicate.name
+      arguments = goal.arguments.arguments
+      arg_block = goal.arguments.block
+      
+      Predicate.call_builtin(predicate, goal, block, *arguments, &arg_block)
+    end
+    
+    # Call a builtin predicate
+    # @param predicate [Symbol] the name of the predicate to call.
+    # @param args [Array<Object>] arguments for the predicate call.
+    # @param arg_block [Proc] the block provided in the Arguments of the Predicate.
+    # @return [Boolean] whether the predicate was satisfied.
+    def self.call_builtin(predicate, *args, &arg_block)
+      Porolog::Predicate::Builtin.instance_method(predicate).bind(self).call(*args, &arg_block)
     end
     
   end