rubylog 0.0.1 → 1.0.0

data/lib/rubylog/interfaces/procedure.rb

@@ -0,0 +1,60 @@
+module Rubylog::Procedure
+  include Rubylog::Predicate
+
+  # accepts the *args of the called structure
+  def call *args
+    catch :cut do
+      each do |rule|
+        begin
+          rule = rule.rubylog_compile_variables
+          head, body = rule[0], rule[1]
+          Rubylog.current_theory.print_trace 1, head.args, "=", args
+          head.args.rubylog_unify(args) { 
+            begin
+              Rubylog.current_theory.print_trace 1, head, head.rubylog_variables_hash
+              body.prove { 
+                yield 
+              }
+            ensure
+              Rubylog.current_theory.print_trace -1
+            end
+          }
+        ensure
+          Rubylog.current_theory.print_trace -1
+        end
+      end
+    end
+  end
+
+  def discontiguous!
+    @discontiguous = true
+  end
+
+  def discontiguous?
+    @discontiguous
+  end
+
+  def multitheory!
+    @multitheory = true
+  end
+
+  def multitheory?
+    @multitheory
+  end
+
+  # In case of a procedure, `each` can be implemented, which should yield all
+  # clauses. This makes reflection possible.
+  #
+  # def each
+  #   yield ...
+  # end
+  #
+  # this should be implemented to enable assertions
+  # def assertz clause
+  #  ...
+  # end
+  #
+  # def assertz clause
+  #  ...
+  # end
+end

data/lib/rubylog/interfaces/term.rb

@@ -0,0 +1,41 @@
+module Rubylog::Term
+  def rubylog_clone
+    yield self
+  end
+
+  def rubylog_variables
+    []
+  end
+
+  def rubylog_resolve_function
+    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
+    end
+  end
+
+  def rubylog_dereference
+    self
+  end
+
+  def rubylog_deep_dereference
+    self
+  end
+
+  def rubylog_compile_variables
+    self
+  end
+end
+
+
+

data/lib/rubylog/mixins/array.rb

@@ -0,0 +1,118 @@
+module Rubylog
+  # for the future
+  def self.unify_arrays a, a_start, a_end, b, b_start, b_end
+    case
+    when (a_start > a_end and b_start > b_end)
+      yield
+    when (a_start > a_end or b_start > b_end)
+      return
+    when (a[a_start].is_a? Rubylog::DSL::ArraySplat and b[b_start].is_a? Rubylog::DSL::ArraySplat)
+      raise "not implemented"
+    when (a[a_start].is_a? Rubylog::DSL::ArraySplat)
+      # A=[]
+      a[a_start].var.rubylog_unify [] do
+        unify_arrays(a, a_start+1, a_end, b, b_start, b_end) { yield }
+      end
+
+      # A=[_X, *_Y]
+      new_arr = [Rubylog::Variable.new, Rubylog::DSL::ArraySplat.new(Rubylog::Variable.new)]
+      a[a_start].var.rubylog_unify new_arr do
+        unify_arrays(a[a_start].var, a_start+1, a_end, b, b_start, b_end) { yield }
+      end
+    when (b[b_start].is_a? Rubylog::DSL::ArraySplat)
+      raise "not implemented"
+    else
+      a[a_start].rubylog_unify b[b_start] do 
+        unify_arrays(a, a_start+1, a_end, b, b_start+1, b_end) { yield }
+      end
+    end
+  end
+end
+
+class Array
+
+  # Term methods
+  def rubylog_unify other
+    return super{yield} unless other.instance_of? self.class
+    #Rubylog.unify_arrays(self, 0, length-1, other, 0, other.length-1) { yield }
+    if empty?
+      if other.empty?
+        yield
+      elsif other[0].is_a? Rubylog::DSL::ArraySplat
+        other[0].var.rubylog_unify [] do
+          self.rubylog_unify other[1..-1] do
+            yield
+          end
+        end
+      else
+        # failed
+      end
+    else
+      if self[0].is_a? Rubylog::DSL::ArraySplat
+        # optimize [*A] = [*B]
+        if other[0].is_a? Rubylog::DSL::ArraySplat and self.length == 1 and other.length == 1
+          self[0].var.rubylog_unify other[0].var do
+            yield
+          end
+          return
+        end
+
+        self[0].var.rubylog_unify [] do
+          self[1..-1].rubylog_unify other do
+            yield
+          end
+        end
+        part = [Rubylog::Variable.new, Rubylog::DSL::ArraySplat.new]
+        self[0].var.rubylog_unify part do
+          (part + self[1..-1]).rubylog_unify other do
+            yield
+          end
+        end
+      else
+        if other[0].is_a? Rubylog::DSL::ArraySplat
+          other[0].var.rubylog_unify [] do
+            self.rubylog_unify other[1..-1] do
+              yield
+            end
+          end
+          part = [Rubylog::Variable.new, Rubylog::DSL::ArraySplat.new]
+          other[0].var.rubylog_unify part do
+            self.rubylog_unify(part + other[1..-1]) do
+              yield
+            end
+          end
+        else
+          return if other.empty?
+          self[0].rubylog_unify other[0] do
+            self[1..-1].rubylog_unify other[1..-1] do
+              yield
+            end
+          end
+        end
+      end
+    end
+  end
+
+  # CompositeTerm methods
+  include Rubylog::CompositeTerm
+  def rubylog_clone &block
+    block[map{|t|t.rubylog_clone &block}]
+  end
+
+  def rubylog_deep_dereference 
+    map do |t|
+      case t
+      when Rubylog::DSL::ArraySplat
+        v = t.var.rubylog_dereference
+        if v.is_a? Array
+          v.rubylog_deep_dereference
+        else
+          [t]
+        end
+      else
+        [t.rubylog_deep_dereference]
+      end
+    end.inject(:concat) || []
+  end
+  
+end

data/lib/{class.rb → rubylog/mixins/class.rb}

@@ -1,7 +1,7 @@
 class Class
-  def include_theory *theories
+  def use_theory *theories
     raise ArgumentError, "no theory given" if theories.empty?
-    theories.each {|t| include t.public_interface}
+    theories.each {|t| t.subject self }
   end
 
   def rubylog_functor *functors

data/lib/rubylog/mixins/hash.rb

@@ -0,0 +1,8 @@
+class Hash
+  def rubylog_matches_as_guard? other
+    self.each_pair do |k,v|
+      return false unless v.rubylog_matches_as_guard? other.send(*k)
+    end
+    true
+  end
+end

data/lib/rubylog/mixins/kernel.rb

@@ -0,0 +1,5 @@
+module Kernel
+  def theory *args, &block
+    Rubylog.theory *args, &block
+  end
+end

data/lib/rubylog/mixins/method.rb

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

data/lib/rubylog/mixins/object.rb

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

data/lib/rubylog/mixins/proc.rb

@@ -0,0 +1,37 @@
+class Proc
+
+  # Callable methods
+  include Rubylog::Callable
+
+  def prove
+    yield if call_with_rubylog_variables
+  end
+
+  # CompositeTerm methods
+  include Rubylog::CompositeTerm
+  def rubylog_clone 
+    yield dup
+  end
+
+
+
+  # Term methods
+  def rubylog_resolve_function
+    call_with_rubylog_variables
+  end
+
+  def call_with_rubylog_variables vars = nil
+    vars ||= @rubylog_variables
+    raise Rubylog::InvalidStateError, "variables not available" if not vars
+
+    Rubylog::Theory.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

@@ -0,0 +1,104 @@
+class String
+  RUBYLOG_VAR_START = "\u0091" # "\u00ab"
+  RUBYLOG_VAR_END   = "\u0092" # "\u00bb"
+  RUBYLOG_VAR_REGEXP = /#{RUBYLOG_VAR_START}([^\[]+?)\[(\d*)\]#{RUBYLOG_VAR_END}/
+
+  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
+      end
+    else
+      b.scan /#{Regexp.quote(a_segments[0])}/ do
+        a_vars[0].rubylog_unify(b[0...Regexp.last_match.begin(0)]) do
+          rubylog_unify_strings(a, a_segments[1..-1], a_vars[1..-1], b[Regexp.last_match.end(0)..-1]) do
+            yield
+          end
+        end
+      end
+    end
+  end
+
+  # Term methods
+  def rubylog_unify other
+    return super{yield} unless other.instance_of? self.class
+
+    self_has_vars = self =~ RUBYLOG_VAR_REGEXP
+    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
+
+    a, b = self_has_vars ? [self, other] : [other, self]
+    a_segments, a_vars = a.rubylog_segments
+
+    return unless b.start_with? a_segments[0]
+    b = b[a_segments[0].length..-1]; a_segments.shift
+
+    String.rubylog_unify_strings(a, a_segments, a_vars, b) do
+      yield
+    end
+
+  end
+
+  # CompositeTerm methods
+  include Rubylog::CompositeTerm
+  def rubylog_clone &block
+    scan RUBYLOG_VAR_REGEXP do
+      guards = RubylogStringVariableGuards[$2.to_i] 
+      Rubylog::Variable.new($1.to_sym)[*guards].rubylog_clone(&block)
+    end
+    block[self]
+  end
+
+  def rubylog_deep_dereference 
+    gsub RUBYLOG_VAR_REGEXP do
+      rubylog_get_string_variable($1).rubylog_deep_dereference.to_s
+    end
+  end
+
+  # returns a list of substrings which are before, between and after the rubylog
+  # string variables
+  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])
+    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
+  end
+
+end

data/lib/rubylog/mixins/symbol.rb

@@ -0,0 +1,44 @@
+class Symbol
+
+  # a proxy for Structure
+  def functor
+    self
+  end
+
+  def arity
+    0
+  end
+
+  def indicator
+    [self, 0]
+  end
+
+  def args
+    []
+  end
+
+  # Assertable methods
+  include Rubylog::Assertable
+
+  # Term methods
+  include Rubylog::Term
+
+  # Callable methods
+  include Rubylog::Callable
+
+  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
+  end
+
+
+end

data/lib/rubylog/simple_procedure.rb

@@ -0,0 +1,8 @@
+class Rubylog::SimpleProcedure < Array
+  include Rubylog::Procedure
+
+  alias assertz <<
+  alias asserta unshift
+end
+
+

data/lib/rubylog/{clause.rb → structure.rb}

@@ -1,9 +1,10 @@
 module Rubylog
-  class Clause
+  class Structure
 
     # data structure
     attr_reader :functor, :args
     def initialize functor, *args
+      #raise Rubylog::TypeError, "functor cannot be #{functor}" unless functor.is_a? Symbol
       @functor = functor
       @args = args.freeze
       @arity = args.count
@@ -14,7 +15,7 @@ module Rubylog
     end
 
     def == other
-      other.instance_of? Clause and
+      other.instance_of? Structure and
       @functor == other.functor and @args == other.args
     end
     alias eql? ==
@@ -37,38 +38,36 @@ module Rubylog
       @arity
     end
 
-    def desc
+    def indicator
       [@functor, @arity]
     end
 
-    # assertion routines
-    def if body=nil, &block
-      Rubylog.theory.assert self, body || block
-    end
-
-    def unless body=nil, &block
-      Rubylog.theory.assert self, Clause.new(:is_false, body || block)
-    end
-
-
+    # Assertable methods
+    include Rubylog::Assertable
 
     # Callable methods
     include Rubylog::Callable
 
     def prove
-      Rubylog.theory.trace 1, self, InternalHelpers.vars_hash_of(self)
-      predicate = Rubylog.theory[@functor][@arity]
-      raise ExistenceError, desc.inspect if not predicate
-      predicate.call(*@args) { yield }
-      Rubylog.theory.trace -1
+      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
     end
+    
 
     # enumerable methods
     include Enumerable
     alias each solve
 
-    # Unifiable methods
-    include Rubylog::Unifiable
+    # Term methods
+    include Rubylog::Term
     def rubylog_unify other
       return super{yield} unless other.instance_of? self.class
       return unless other.functor == @functor
@@ -81,20 +80,22 @@ module Rubylog
     # CompositeTerm methods
     include Rubylog::CompositeTerm
     def rubylog_clone &block
-      block.call Clause.new @functor,
-        *@args.map{|a|a.rubylog_clone &block}
+      block.call Structure.new @functor,
+        *@args.map{|a| a.rubylog_clone &block}
+    end
+    def rubylog_deep_dereference
+      Structure.new @functor.rubylog_deep_dereference,
+        *@args.rubylog_deep_dereference
     end
 
-    # Second-order functors (:is_false, :and, :or, :then)
-    include Rubylog::DSL::SecondOrderFunctors
 
     # convenience methods
-    def solutions
-      goal = rubylog_compile_variables 
-      goal.variable_hashes_without_compile.map do |hash|
-        goal.rubylog_clone {|i| hash[i] || i }
-      end
-    end
+    #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
@@ -109,5 +110,5 @@ module Rubylog
       end
     end
   end
-
 end
+