rubylog 1.0.0 → 2.0pre1

data/lib/rubylog/mixins/kernel.rb

@@ -1,5 +1,6 @@
 module Kernel
-  def theory *args, &block
-    Rubylog.theory *args, &block
+  # Calls the given block within the default Rubylog context (::Rubylog)
+  def rubylog &block
+    Rubylog::DefaultContext.instance_exec &block
   end
 end

data/lib/rubylog/mixins/method.rb

@@ -1,3 +1,2 @@
 class Method
-  include Rubylog::Predicate
 end

data/lib/rubylog/mixins/object.rb

@@ -2,7 +2,8 @@ class Object
   include Rubylog::Term
 
   def rubylog_matches_as_guard? other
-    Rubylog.current_theory.print_trace 0, "#{inspect}===#{other.inspect}"
     self === other
   end
+
+  rubylog_traceable :rubylog_matches_as_guard?
 end

data/lib/rubylog/mixins/proc.rb

@@ -1,14 +1,14 @@
 class Proc
 
-  # Callable methods
-  include Rubylog::Callable
+  # Clause methods
+  include Rubylog::Clause
 
   def prove
     yield if call_with_rubylog_variables
   end
 
-  # CompositeTerm methods
-  include Rubylog::CompositeTerm
+  # CompoundTerm methods
+  include Rubylog::CompoundTerm
   def rubylog_clone 
     yield dup
   end
@@ -20,18 +20,15 @@ class Proc
     call_with_rubylog_variables
   end
 
+  # Calls the proc with the given rubylog variables or with the currently
+  # available variables.
   def call_with_rubylog_variables vars = nil
     vars ||= @rubylog_variables
-    raise Rubylog::InvalidStateError, "variables not available" if not vars
+    raise Rubylog::InvalidStateError, "Variables not matched" if not vars
 
-    Rubylog::Theory.with_vars vars do
+    # Call the block with the variables substituted
+    Rubylog::DSL::Variables.with_vars vars do
       return call
     end
-    # to pass arguments:
-    #if arity == -1
-    #  call *@rubylog_variables.map{|v|v.value}
-    #else
-    #  call *@rubylog_variables[0...arity].map{|v|v.value}
-    #end
   end
 end

data/lib/rubylog/mixins/string.rb

@@ -6,11 +6,9 @@ class String
   RubylogStringVariableGuards = [[]]
 
   def self.rubylog_unify_strings a, a_segments, a_vars, b
-    #p a, a_segments, a_vars, b
     if a_segments.count == 1
       segment = a_segments[0]
       if b.end_with?(segment)
-        #p b[0...b.length-segment.length]
         a_vars[0].rubylog_unify b[0...b.length-segment.length] do
           yield
         end
@@ -34,7 +32,7 @@ class String
     other_has_vars = other =~ RUBYLOG_VAR_REGEXP
 
     return super{yield} unless self_has_vars or other_has_vars
-    raise Rubylog::InstantiationError, "Cannot unify two strings with variables inside" if self_has_vars and other_has_vars
+    raise ArgumentError, "Cannot unify two strings with variables inside" if self_has_vars and other_has_vars
 
     a, b = self_has_vars ? [self, other] : [other, self]
     a_segments, a_vars = a.rubylog_segments
@@ -48,8 +46,8 @@ class String
 
   end
 
-  # CompositeTerm methods
-  include Rubylog::CompositeTerm
+  # CompoundTerm methods
+  include Rubylog::CompoundTerm
   def rubylog_clone &block
     scan RUBYLOG_VAR_REGEXP do
       guards = RubylogStringVariableGuards[$2.to_i] 
@@ -60,45 +58,39 @@ class String
 
   def rubylog_deep_dereference 
     gsub RUBYLOG_VAR_REGEXP do
-      rubylog_get_string_variable($1).rubylog_deep_dereference.to_s
+      rubylog_get_string_variable($1,$2).rubylog_deep_dereference.to_s
     end
   end
 
-  # returns a list of substrings which are before, between and after the rubylog
-  # string variables
+  # returns a list of substrings which are before, between and after the
+  # rubylog
+  # string variables, and the list of variabes in between
   def rubylog_segments
     segments = [[0]]
     vars = []
 
     scan RUBYLOG_VAR_REGEXP do
       match = Regexp.last_match
-      #p match
-      #p match.begin(0)
-      #p match.end(0)
-      #p match[0]
-      #p match[1]
       segments.last << match.begin(0)
       segments << [match.end(0)]
-      vars << rubylog_get_string_variable(match[1])
+      vars << rubylog_get_string_variable(match[1], match[2])
     end
     
 
     segments.last << length
-    #p segments, vars
     segments = segments.map{|s|self[s[0]...s[1]]}
-    #p [self, segments, vars]
     return segments, vars
   end
 
   protected
 
-  def rubylog_get_string_variable s
-    s = s.to_sym
-    if @rubylog_variables
-      @rubylog_variables.find{|v|v.name == s}
-    else
-      raise Rubylog::InvalidStateError, "Rubylog variables not available"
-    end
+  # 
+  def rubylog_get_string_variable name, guards_index
+    name = name.to_sym
+    raise Rubylog::InvalidStateError, "Variables not matched" unless @rubylog_variables
+
+    @rubylog_variables.find{|v|v.name == name} || 
+      Rubylog::Variable.new[*RubylogStringVariableGuards[guards_index.to_i]]
   end
 
 end

data/lib/rubylog/mixins/symbol.rb

@@ -1,16 +1,7 @@
 class Symbol
 
-  # a proxy for Structure
-  def functor
-    self
-  end
-
-  def arity
-    0
-  end
-
-  def indicator
-    [self, 0]
+  def predicate
+    Rubylog::NullaryPredicates[self] or raise Rubylog::ExistenceError.new(self)
   end
 
   def args
@@ -23,22 +14,14 @@ class Symbol
   # Term methods
   include Rubylog::Term
 
-  # Callable methods
-  include Rubylog::Callable
+  # Clause methods
+  include Rubylog::Clause
 
   def prove
-    begin
-      Rubylog.current_theory.print_trace 1, self, rubylog_variables_hash
-
-      predicate = Rubylog.current_theory[[self,0]]
-      raise Rubylog::ExistenceError, indicator if not predicate
-
-      predicate.call(*args) { yield }
-
-    ensure
-      Rubylog.current_theory.print_trace -1
-    end
+    predicate.call { yield }
   end
 
+  rubylog_traceable :prove
+
 
 end

data/lib/rubylog/nullary_predicates.rb

@@ -0,0 +1,3 @@
+module Rubylog
+  NullaryPredicates = {}
+end

data/lib/rubylog/predicate.rb

@@ -0,0 +1,53 @@
+module Rubylog
+  class Predicate
+
+    attr_reader :functor, :arity
+    def initialize functor, arity
+      @functor = functor
+      @arity = arity
+    end
+
+    # Yields for each solution of the predicate
+    def call *args
+      raise "abstract method called on #{self.inspect}"
+    end
+
+    def add_functor_to subjects
+      if arity == 0
+        # We treat nullary predicates differently. Do not even create functors.
+        Rubylog::NullaryPredicates[functor] = self
+        return
+      end
+
+      predicate = self
+
+      [subjects].flatten.each do |subject|
+        raise ArgumentError, "#{subject.inspect} is not a class or module" unless subject.is_a? Module
+        subject.class_eval do
+          f = predicate.functor
+          define_method f do |*args, &block|
+          args << block if block
+          Rubylog::Structure.new predicate, f, self, *args 
+          end
+
+          f_bang = :"#{f}!"
+          define_method f_bang do |*args, &block|
+          args << block if block
+          predicate.assert Rubylog::Structure.new(predicate, f, self, *args), :true
+          self
+          end
+
+          f_qmark = :"#{f}?"
+          define_method f_qmark do |*args, &block|
+          args << block if block
+          Rubylog::Structure.new(predicate, f, self, *args).true?
+          end
+        end
+      end
+
+    end
+
+
+
+  end
+end

data/lib/rubylog/primitive.rb

@@ -0,0 +1,15 @@
+module Rubylog
+  class Primitive < Predicate
+
+    def initialize functor, callable
+      super functor, callable.arity
+      @callable = callable
+    end
+
+    # calls the callable with the argumens
+    def call *args
+      @callable.call(*args) { yield }
+    end
+
+  end
+end

data/lib/rubylog/procedure.rb

@@ -0,0 +1,42 @@
+module Rubylog
+  class Procedure < Predicate
+    include Enumerable
+
+    def initialize functor, arity, rules=Array.new
+      super functor, arity
+      @rules = rules
+    end
+
+    def method_missing name, *args, &block
+      @rules.send name, *args, &block
+    end
+
+    # accepts the *args of the called structure
+    def call *args
+      # catch cuts
+      catch :cut do
+
+        # for each rule
+        each do |rule|
+          # compile
+          rule = rule.rubylog_match_variables
+
+          # unify the head with the arguments
+          rule.head.args.rubylog_unify(args) do
+            # call the body
+            rule.body.prove do
+              yield 
+            end
+          end
+        end
+      end
+    end
+    rubylog_traceable :call
+
+    # Asserts a rule with a given head and body.
+    def assert head, body=:true
+      push Rubylog::Rule.new(head, body)
+    end
+
+  end
+end

data/lib/rubylog/rule.rb

@@ -0,0 +1,24 @@
+module Rubylog
+
+  # This is an internally used class that represents a rule of a predicate.
+  #
+  class Rule
+    attr_reader :head, :body
+
+    def initialize head, body
+      @head = head
+      @body = body
+    end
+
+    # CompoundTerm methods
+    include Rubylog::CompoundTerm
+    def rubylog_clone &block
+      block.call Rule.new @head.rubylog_clone(&block), @body.rubylog_clone(&block)
+    end
+    def rubylog_deep_dereference
+      # this is not necessary
+      #Rule.new @head.rubylog_deep_dereference, @body.rubylog_deep_dereference
+      raise "Not implemented."
+    end
+  end
+end

data/lib/rubylog/structure.rb

@@ -3,13 +3,19 @@ module Rubylog
 
     # data structure
     attr_reader :functor, :args
-    def initialize functor, *args
+
+    def initialize predicate, functor, *args
       #raise Rubylog::TypeError, "functor cannot be #{functor}" unless functor.is_a? Symbol
+      @predicate = predicate
       @functor = functor
       @args = args.freeze
       @arity = args.count
     end
 
+    def predicate
+      @predicate 
+    end
+
     def [] i
       @args[i]
     end
@@ -45,21 +51,15 @@ module Rubylog
     # Assertable methods
     include Rubylog::Assertable
 
-    # Callable methods
-    include Rubylog::Callable
+    # Clause methods
+    include Rubylog::Clause
 
     def prove
-      begin
-        Rubylog.current_theory.print_trace 1, self, rubylog_variables_hash
-        predicate = Rubylog.current_theory[indicator]
-        raise Rubylog::ExistenceError, indicator.inspect if not predicate
-        count = 0
-        predicate.call(*@args) { yield; count+=1 }
-        count
-      ensure
-        Rubylog.current_theory.print_trace -1
-      end
+      count = 0
+      predicate.call(*@args) { yield; count+=1 }
+      count
     end
+    rubylog_traceable :prove
     
 
     # enumerable methods
@@ -77,38 +77,19 @@ module Rubylog
 
     attr_reader :rubylog_variables
 
-    # CompositeTerm methods
-    include Rubylog::CompositeTerm
+    # CompoundTerm methods
+    include Rubylog::CompoundTerm
+
     def rubylog_clone &block
-      block.call Structure.new @functor,
+      block.call Structure.new @predicate, @functor.rubylog_clone(&block),
         *@args.map{|a| a.rubylog_clone &block}
     end
+
     def rubylog_deep_dereference
-      Structure.new @functor.rubylog_deep_dereference,
+      Structure.new @predicate, @functor.rubylog_deep_dereference,
         *@args.rubylog_deep_dereference
     end
 
-
-    # convenience methods
-    #def each_solution
-      #goal = rubylog_compile_variables 
-      #goal.variable_hashes_without_compile.each do |hash|
-        #yield goal.rubylog_clone {|i| hash[i] || i }
-      #end
-    #end
-
-    def variable_hashes
-      rubylog_compile_variables.variable_hashes_without_compile
-    end
-
-    protected
-
-    def variable_hashes_without_compile
-      variables = rubylog_variables
-      map do |*values|
-        Hash[variables.zip values]
-      end
-    end
   end
 end
 

data/lib/rubylog/{interfaces/term.rb → term.rb}

@@ -11,16 +11,11 @@ module Rubylog::Term
     self
   end
 
-  def rubylog_variables_hash
-    vars = rubylog_variables
-    Hash[vars.zip(vars.map{|v|v.value})]
-  end
-
   def rubylog_unify other
     if other.kind_of? Rubylog::Variable
       other.rubylog_unify(self) do yield end
     else
-      yield if self == other
+      yield if self.eql? other
     end
   end
 
@@ -32,7 +27,7 @@ module Rubylog::Term
     self
   end
 
-  def rubylog_compile_variables
+  def rubylog_match_variables
     self
   end
 end

data/lib/rubylog/tracing.rb

@@ -0,0 +1,75 @@
+class Class
+  def rubylog_traceable name
+    Rubylog.traceable instance_method(name)
+  end
+end
+
+module Rubylog
+  module Tracing
+    attr_reader :traceable_methods
+    attr_accessor :trace_levels
+
+    # Turns trace on. If value is given and is false, turns trace off. If a
+    # block is given, calls the block with trace on.
+    #
+    def trace value=true
+      if not block_given?
+        @trace = value
+        @trace_levels = 0
+        update_trace
+      else
+        begin
+          trace
+          return yield
+        ensure
+          trace false
+        end
+      end
+    end
+
+    # returns true if tracing is active
+    def trace?
+      @trace
+    end
+
+
+    def traceable method
+      @traceable_methods ||= []
+      @traceable_methods << method
+    end
+
+    private
+
+    def update_trace
+      if trace?
+        traceable_methods.each do |m|
+          m.owner.send :define_method, m.name do |*args,&block|
+            begin
+              print " "*Rubylog.trace_levels
+              Rubylog.trace_levels += 1
+              print "#{inspect}.#{m.name}(#{args.map{|k|k.inspect}.join(", ")})?"
+              gets
+
+              return m.bind(self).call *args, &block
+            ensure
+              Rubylog.trace_levels -= 1
+              print " "*Rubylog.trace_levels
+              print "*"
+              puts
+            end
+          end
+        end
+      else
+        traceable_methods.each do |m|
+          m.owner.send :define_method, m.name do |*args, &block|
+            m.bind(self).call(*args, &block)
+          end
+        end
+      end
+
+    end
+  end
+  extend Tracing
+end
+
+

data/lib/rubylog/variable.rb

@@ -35,8 +35,7 @@ module Rubylog
 
 
     def value
-      return nil if (val = rubylog_dereference).kind_of? Variable
-      val
+      @value if @bound
     end
 
     def dont_care? 
@@ -51,7 +50,13 @@ module Rubylog
       [self]
     end
 
-    # unify two variables
+    # Unifies the receiver with another value.
+    #
+    # First dereferences both the receiver and the other. If both dereferenced
+    # values are variables, unifies them with the other being bound to the
+    # receiver. If one of them is a variable, it gets bound to the other value.
+    # If none of them is a variable, they are checked for equality with eql?.
+    #
     def rubylog_unify other
       # check if we are bound
       if @bound
@@ -68,7 +73,9 @@ module Rubylog
         if other.is_a? Rubylog::Variable
           # we union our guards with the other's
           other.append_guards guards do
-            bind_to other do
+            # we bind the other to self (this order comes from
+            # inriasuite_spec#unify)
+            other.bind_to self do
               yield
             end
           end
@@ -102,13 +109,21 @@ module Rubylog
       end
     end
 
-    # Callable methods
-    include Callable
+    # Clause methods
+    include Clause
 
     def prove
-      v = value
-      raise InstantiationError, self if v.nil?
-      v.prove{yield}
+      v = rubylog_dereference
+      raise Rubylog::InstantiationError.new(self) if v.is_a? Rubylog::Variable
+
+      # match variables if not matched
+      unless v.rubylog_variables
+        v = v.rubylog_match_variables
+      end
+      
+      catch :cut do
+        v.prove{yield}
+      end
     end
 
 
@@ -145,15 +160,19 @@ module Rubylog
     def bind_to other
       begin
         @bound = true; @value = other
-        Rubylog.current_theory.print_trace 1, "#{inspect}=#{@value.inspect}"
 
         yield
-
       ensure
         @bound = false
-        Rubylog.current_theory.print_trace -1
       end
     end
+    rubylog_traceable :bind_to
+
+    def bind_to! other
+      @bound = true; @value = other
+      self
+    end
+    private :bind_to!
 
     # yields with self.guards = self.guards + other_guards, then restores guards
     def append_guards other_guards