rubylog 0.0.1 → 1.0.0

data/lib/rubylog/theory.rb

@@ -1,133 +1,422 @@
 module Rubylog
-  class Cut < StandardError
+
+  # @return [Rubylog::Theory] the current theory
+  def self.current_theory
+    Thread.current[:rubylog_current_theory]
+  end
+
+  # Create a new Rubylog theory or modify an existing one.
+  #
+  # You can create theories with the theory method, which is available from
+  # anywhere:
+  #     theory "MyTheory" do
+  #       # ...
+  #     end
+  def self.theory full_name=nil, *args, &block
+    case full_name
+    when nil
+      theory = Rubylog::Theory.new
+    when Rubylog::Theory
+      theory=full_name
+    else
+      names = full_name.to_s.split("::")
+      parent_names, name = names[0...-1], names[-1]
+      parent = parent_names.inject(block.binding.eval("Module.nesting[0]") || Object)  {|a,b| a.const_get b}
+
+      if not parent.const_defined?(name)
+        theory = Rubylog::Theory.new *args
+        parent.const_set name, theory
+      else
+        theory = parent.const_get name
+        raise TypeError, "#{name} is not a theory" unless theory.is_a? Rubylog::Theory
+      end
+    end
+
+    theory.amend &block
+    theory
+  end
+
+end
+
+# The Theory class represents a collection of rules.
+class Rubylog::Theory
+
+  
+  include Rubylog::DSL::Variables
+  
+  # Call the given block with variables automatically resolved
+  def self.with_vars vars
+    begin
+      old_vars = Thread.current[:rubylog_current_variables]
+      Thread.current[:rubylog_current_variables] = vars
+      yield
+    ensure
+      Thread.current[:rubylog_current_variables] = old_vars
+    end
   end
 
-  def self.theory
-    Thread.current[:rubylog_theory]
+  attr_reader :public_interface, :included_theories, :prefix_functor_modules
+
+  def initialize base=Rubylog::DefaultBuiltins, &block
+    clear
+    include base if base
+
+    if block
+      with_context &block
+    end
   end
 
-  class Theory
-    include Rubylog::DSL::Constants
+  def [] indicator
+    @database[indicator]
+  end
+
+  def []= indicator, predicate
+    @database[indicator] = predicate
+  end
 
-    def self.new!
-      Thread.current[:rubylog_theory] = new
+  def keys
+    @database.keys
+  end
+
+  def each_pair
+    if block_given?
+      @database.each_pair {|*a| yield *a }
+    else
+      @database.each_pair
     end
+  end
+
+  # Clear all data in the theory and bring it to its initial state.
+  def clear
+    @database = {}
+    @primitives = Rubylog::DSL::Primitives.new self
+    @variable_bindings = []
+    @public_interface = Module.new
+    @subjects = []
+    @trace = false
+    @implicit = false
+    @check_discontiguous = true
+    @included_theories = []
+    @check_number = 0
+    @prefix_functor_modules = []
+  end
+
+  def primitives
+    @primitives
+  end
+  private :primitives
+
+  def with_context &block
+    begin
+      # save current theory
+      old_theory = Thread.current[:rubylog_current_theory]
+      Thread.current[:rubylog_current_theory] = self
+
+      # start implicit mode
+      if @implicit
+        start_implicit
+      end
 
-    def initialize
-      @database = Hash.new{|h,k| h[k] = 
-        {}
-      }.merge! BUILTINS
-      @variable_bindings = []
-      @public_interface = Module.new
-      @trace = false
+      # call the block
+      return instance_exec &block
+    ensure 
+      # restore current theory
+      Thread.current[:rubylog_current_theory] = old_theory
+
+      # stop implicit mode
+      if @implicit_started
+        stop_implicit
+      end
     end
+  end
+  
+  alias amend with_context
+  alias eval with_context
 
-    def [] *args
-      database[*args]
+
+  # directives
+  #
+  def predicate *indicators
+    indicators.each do |indicator|
+      check_indicator indicator
+      create_procedure indicator
     end
+  end
 
-    def clear
-      initialize
+  def discontiguous *indicators
+    indicators.each do |indicator|
+      check_indicator indicator
+      create_procedure(indicator).discontiguous!
     end
+  end
+
+  def check_discontiguous value = true
+    @check_discontiguous = value
+  end
+
+  def check_discontiguous?
+    @check_discontiguous
+  end
 
+  def multitheory *indicators
+    indicators.each do |indicator|
+      check_indicator indicator
+      create_procedure(indicator).multitheory!
+    end
+  end
 
-    # directives
-    #
-    def predicate *descs
-      descs.each do |desc|
-        create_predicate *desc
+  def functor *functors
+    functors.each do |fct|
+      Rubylog::DSL.add_functors_to @public_interface, fct
+      @subjects.each do |s|
+        Rubylog::DSL.add_functors_to s, fct
       end
     end
+  end
+
+  def prefix_functor *functors
+    functors.each do |fct|
+      m = Module.new
+      Rubylog::DSL.add_prefix_functors_to m, fct
+      @prefix_functor_modules << m
+      extend m
+    end
+  end
+
+  def functor_for target, *functors
+    functors.each do |fct|
+      Rubylog::DSL.add_functors_to target, fct
+    end
+  end
+
+  def private *indicators
+  end
+
+  def subject *subjects
+    subjects.each do |s|
+      s.send :include, @public_interface
+      @subjects << s
+    end
+  end
+
+  def include *theories
+    theories.each do |theory|
+
+      @included_theories << theory
 
-    def discontinuous *descs
-      descs.each do |desc|
-        create_predicate(*desc).discontinuous!
+      # include all public_interface predicates
+      @public_interface.send :include, theory.public_interface
+      theory.each_pair do |indicator, predicate|
+        if keys.include? indicator and self[indicator].respond_to? :multitheory? and self[indicator].multitheory?
+          raise TypeError, "You can only use a procedure as a multitheory predicate (#{indicator})" unless predicate.respond_to? :each
+          predicate.each do |rule|
+            @database[indicator].assertz rule
+          end
+        else
+          @database[indicator] = predicate
+        end
       end
+
+      # include prefix_functors
+      theory.prefix_functor_modules.each do |m|
+        @prefix_functor_modules << m
+        extend m
+      end
+
     end
+  end
+
+
+  def explain c
+    require "rubylog/because"
+    include Rubylog::Because unless included_theories.include? Rubylog::Because
+    expl = Rubylog::Variable.new :_expl
+    c.because(expl).solve do
+      return c.because(expl.value)
+    end
+  end
+
+  def check_passed goal
+    print "#{n = check_number} :)\t"
+  end
 
-    attr_reader :database
-    attr_reader :public_interface
+  def check_failed goal
+    puts "#{check_number} :/\t"
+    puts "Check failed: #{goal.inspect}"
+    puts caller[1]
+    #raise Rubylog::CheckFailed, goal.inspect, caller[1..-1]
+  end
 
+  def check_raised_exception goal, exception
+    puts "#{check_number} :(\t"
+    puts "Check raised exception: #{exception}"
+    puts exception.backtrace
+  end
 
-    # predicates
+  # returns the line number of the most recen +check+ call
+  def check_number
+    i = caller.index{|l| l.end_with? "in `check'" }
+    caller[i+1] =~ /:(\d+):/
+    $1
+  end
+  private :check_number
 
-    def assert head, body=:true
-      functor, arity = head.functor, head.arity
-      predicate = database[functor][arity]
-      if predicate
-        check_assertable predicate, head, body
+  # Tries to prove goal (or block if goal is not given). If it proves, calles
+  # +check_passed+. If it fails, calls +check_failed+. If it raises an exception, calls +check_raised_exception+.
+  def check goal=nil, &block
+    goal ||= block
+    result = nil
+    begin 
+      result = true?(goal)
+    rescue
+      check_raised_exception goal, $!
+    else
+      if result
+        check_passed goal, &block
       else
-        predicate = create_predicate functor, arity
+        check_failed goal, &block
       end
-      predicate << Clause.new(:-, head, body)
-      @last_predicate = predicate
     end
+    result
+  end
+    
+  # Starts (if +val+ is not given or true) or stops (if +val+ is false) implicit mode.
+  #
+  # In implicit mode you can start using infix functors without declaring them.
+  def implicit val=true
+    @implicit = val
+
+    if val
+      if Thread.current[:rubylog_current_theory] == self
+        start_implicit
+      end
+    else
+      if @implicit_started
+        stop_implicit
+      end
+    end
+  end
+
+  def thats
+    Rubylog::DSL::Thats.new
+  end
+
+
+  # predicates
+
+  def assert head, body=:true
+    indicator = head.indicator
+    predicate = @database[indicator]
+    if predicate
+      check_assertable predicate, head, body
+    else
+      predicate = create_procedure indicator
+    end
+    predicate.assertz Rubylog::Structure.new(:-, head, body)
+    @last_predicate = predicate
+  end
 
 
-    def solve goal
+  def solve goal, &block
+    with_context do
       goal = goal.rubylog_compile_variables 
-      goal.prove { yield(*goal.rubylog_variables.map{|v|v.value}) }
+      goal.prove { block.call_with_rubylog_variables(goal.rubylog_variables) }
     end
+  end
 
-    def true? goal
+  def true? goal=nil, &block
+    if goal.nil? 
+      raise ArgumentError, "No goal given" if block.nil?
+      goal = with_context &block
+    end
+    with_context do
       goal = goal.rubylog_compile_variables
       goal.prove { return true }
-      false
     end
+    false
+  end
 
-    # debugging
-    #
-    #
-    def trace?
-      @trace
-    end
+  alias prove true?
 
-    def trace!
-      @trace=true
-      @trace_levels = 0
-    end
+  # debugging
+  #
+  #
+  def trace val=true, &block
+    @trace=block || val
+    @trace_levels = 0
+  end
 
-    def trace level, *args
-      return unless @trace
-      @trace_levels += level
-      puts "  "*level + args.map{|a|a.inspect}.join(" ") if not args.empty?
+  def print_trace level, *args
+    return unless @trace
+    if @trace.respond_to? :call
+      @trace.call @trace_levels, *args if not args.empty?
+    else
+      puts "  "*@trace_levels + args.map{|a|a.rubylog_deep_dereference.to_s}.join(" ") if not args.empty?
     end
+    @trace_levels += level
+  end
+
+  protected
 
-    protected
 
+  def check_assertable predicate, head, body
+    raise Rubylog::NonAssertableError, head.indicator.inspect, caller[2..-1] unless predicate.respond_to? :assertz
+    raise Rubylog::DiscontiguousPredicateError, head.indicator.inspect, caller[2..-1] if check_discontiguous? and not predicate.empty? and predicate != @last_predicate and not predicate.discontiguous?
+  end
+    
+  def create_procedure indicator
+    functor indicator[0]
+    @database[indicator] = Rubylog::SimpleProcedure.new
+  end
 
-    def check_assertable predicate, head, body
-      raise BuiltinPredicateError, head.desc.inspect, caller[2..-1] unless predicate.is_a? Predicate
-      raise DiscontinuousPredicateError, head.desc.inspect, caller[2..-1] if not predicate.empty? and predicate != @last_predicate and not predicate.discontinuous?
+  def start_implicit
+    [@public_interface, Rubylog::Variable].each do |m|
+      m.send :define_method, :method_missing do |m, *args|
+        fct = Rubylog::DSL.normalize_functor(m) 
+        return super if fct.nil?
+        raise NameError, "'#{fct}' method already exists" if respond_to? fct
+        Rubylog.current_theory.functor fct
+        self.class.send :include, Rubylog::DSL.functor_module(fct)
+        send m, *args
+      end
     end
-      
-    def create_predicate functor, arity
-      DSL.add_functors_to @public_interface, functor
-      database[functor][arity] = Predicate.new
+    @implicit_started = true
+  end
+
+  def stop_implicit
+    [@public_interface, Rubylog::Variable].each do |m|
+      m.send :remove_method, :method_missing
     end
-    
+    @implicit_started = false
+  end
+  
 
-    #class << self
-      #def private *args
-        #if args.empty?
-          #@scope = :private
-        #else
-        #end
-      #end
-      #def protected *args
-        #if args.empty?
-          #@scope = :protected
-        #else
-        #end
-      #end
+  #def private *args
+    #if args.empty?
+      #@scope = :private
+    #else
     #end
+  #end
+  #def protected *args
+    #if args.empty?
+      #@scope = :protected
+    #else
+    #end
+  #end
+  
+  private
 
-
+  def check_indicator indicator
+    raise ArgumentError, "#{indicator.inspect} should be a predicate indicator", caller[2..-1] unless indicator.is_a? Array and
+      indicator.length == 2 and
+      indicator[0].is_a? Symbol and
+      indicator[1].is_a? Integer
   end
-end
 
 
 
+end
+
 
 
 

data/lib/rubylog/variable.rb

@@ -4,23 +4,25 @@ module Rubylog
     # data structure
 
     attr_reader :name
-    def initialize name
-      @name = name
-      @assigned = false
-      @dont_care = !!(name.to_s =~ /^(?:ANY|_)/)
+    def initialize name = :"_#{object_id}"
+      @name = name 
+      @bound = false
+      @dont_care = !!(name.to_s =~ /^(?:ANY|_)/i)
+      @guards = []
     end
 
-    def assigned?
-      @assigned
+    def bound?
+      @bound
     end
 
     def inspect
-      @name.to_s
+      if @guards.empty?
+        @name.to_s
+      else
+        "#{@name}#{@guards}"
+      end
     end
 
-    def to_s
-      @name.to_s
-    end
 
     def == other
       Variable === other and @name == other.name
@@ -49,24 +51,43 @@ module Rubylog
       [self]
     end
 
-    # Unifiable methods
-    include Unifiable
-
+    # unify two variables
     def rubylog_unify other
-      if @assigned
+      # check if we are bound
+      if @bound
+        # if we are bound
+        # proceed to our dereferenced value
         rubylog_dereference.rubylog_unify(other) do yield end
       else
-        begin
-          @assigned = true; @value = other
-          yield
-        ensure
-          @assigned = false
+        # if we are unbound
+        
+        # dereference the other
+        other = other.rubylog_dereference
+
+        # if the other is a variable
+        if other.is_a? Rubylog::Variable
+          # we union our guards with the other's
+          other.append_guards guards do
+            bind_to other do
+              yield
+            end
+          end
+        else
+          # if the other is a value
+          # bind to it and 
+          bind_to other do
+            # check our guards
+            if guards.all? {|g|g.rubylog_matches_as_guard? other}
+              yield
+            end
+          end
         end
       end
     end
 
+
     def rubylog_dereference
-      if @assigned
+      if @bound
         @value.rubylog_dereference
       else
         self
@@ -74,7 +95,7 @@ module Rubylog
     end
 
     def rubylog_deep_dereference
-      if @assigned
+      if @bound
         @value.rubylog_deep_dereference
       else
         self
@@ -85,12 +106,70 @@ module Rubylog
     include Callable
 
     def prove
-      # XXX not tested
       v = value
-      raise InstantiationError if v.nil?
+      raise InstantiationError, self if v.nil?
       v.prove{yield}
     end
 
+
+    # Array splats
+    def to_a
+      [Rubylog::DSL::ArraySplat.new(self)]
+    end
+    alias to_ary to_a
+
+    # String variables
+    def to_s
+      if @guards.empty?
+        "#{String::RUBYLOG_VAR_START}#{@name}[]#{String::RUBYLOG_VAR_END}"
+      else
+        String::RubylogStringVariableGuards << @guards
+        guard_index = String::RubylogStringVariableGuards.length-1
+        "#{String::RUBYLOG_VAR_START}#{@name}[#{guard_index}]#{String::RUBYLOG_VAR_END}"
+      end
+    end
+
+    # guards
+    def [] *guards
+      @guards += guards
+      self
+    end
+
+    attr_reader :guards
+    attr_writer :guards
+
+
+    protected
+
+    # yields with self bound to the given value
+    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
+
+    # yields with self.guards = self.guards + other_guards, then restores guards
+    def append_guards other_guards
+      original_guards = @guards
+
+      @guards = @guards + other_guards
+
+      begin
+        yield
+      ensure
+        @guards = original_guards
+      end
+    end
+
+
+
   end