rubylog 1.0.0 → 2.0pre1

data/lib/rubylog/context_creation.rb

@@ -0,0 +1,71 @@
+module Rubylog
+
+  # Creates a new context from a new object or optionally from an existing source
+  # object
+  # @return the new context
+  def self.create_context source_object=Object.new
+    class << source_object
+      include Rubylog::Context
+    end
+    source_object
+  end
+
+
+  # You can use this to access Rubylog in the command line or in the main object.
+  #
+  # For example,
+  # 
+  #   require 'rubylog'
+  #   extend Rubylog::Context
+  #
+  #   solve A.is(5).and { puts A; true }
+  #
+  # You can also use this to convert any object to a context.
+  #
+  # You can extend Rubylog::Context to modules or classes.
+  #
+  # class A
+  #   extend Rubylog::Context
+  #   predicate ".good"
+  # end
+  #
+  # This automatically uses the class as default subject.
+  #
+  # Finally, you can include it to a class.
+  #
+  # class MyContext
+  #   include Rubylog::Context
+  # end
+  #
+  # myc = MyContext.new
+  # myc.predicate_for A, ".bad"
+  #
+  #
+  module Context
+
+    def self.extended context
+      # We include DSL::Variables in its singleton class
+      class << context
+        include Rubylog::DSL::Variables
+      end
+
+      if context.is_a? Module
+        # if context is a class or module, we also include DSL::Variables directly
+        # in it, so that they can be accessed in class_eval mode or from an
+        # instance method.
+        context.send :include, Rubylog::DSL::Variables
+
+        # Also, we set self as a subject, so that +predicate+ automatically attaches
+        # functors to the class.
+        context.default_subject = context
+      end
+    end
+
+    def self.included class_or_module
+      class_or_module.send :include, Rubylog::DSL::Variables
+    end
+
+  end
+
+end
+

data/lib/rubylog/context_modules/checks.rb

@@ -0,0 +1,35 @@
+module Rubylog::ContextModules
+  module Checks
+    def check_passed goal
+    end
+
+    def check_failed goal
+      raise Rubylog::CheckFailed.new(goal)
+    end
+
+    def check_raised_exception goal, exception
+      raise exception
+    end
+
+    # 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 = goal.true?
+      rescue
+        check_raised_exception goal, $!
+      else
+        if result
+          check_passed goal, &block
+        else
+          check_failed goal, &block
+        end
+      end
+      result
+    end
+
+
+  end
+end

data/lib/rubylog/context_modules/demonstration.rb

@@ -0,0 +1,16 @@
+module Rubylog::ContextModules
+  module Demonstration
+    def solve goal, &block
+      goal ||= block
+      raise ArgumentError, "No goal given", caller if goal.nil?
+      goal.solve &block
+    end
+
+    def true? goal=nil, &block
+      goal ||= block
+      raise ArgumentError, "No goal given", caller if goal.nil?
+      goal.true?
+    end
+
+  end
+end

data/lib/rubylog/context_modules/predicates.rb

@@ -0,0 +1,86 @@
+require 'rubylog/rule'
+
+
+module Rubylog
+  module ContextModules
+    module Predicates
+
+      def predicate *indicators
+        each_indicator(indicators) do |indicator|
+          create_procedure(indicator).add_functor_to [default_subject, Variable]
+        end
+      end
+
+      def predicate_for subjects, *indicators
+        each_indicator(indicators) do |indicator|
+          create_procedure(indicator).add_functor_to [subjects, Variable]
+        end
+      end
+
+      def predicate_for_context *indicators
+        each_indicator(indicators) do |indicator|
+          create_procedure(indicator).add_functor_to ::Rubylog::Context
+        end
+      end
+
+      attr_writer :default_subject
+      def default_subject
+        @default_subject || []
+      end 
+
+
+      protected
+
+      def create_procedure indicator
+        Rubylog::Procedure.new indicator[0], indicator[1]
+      end
+
+      def each_indicator indicators
+        # TODO check if not empty
+        #
+        indicators.
+          flatten.
+          map{|str|str.split(" ")}.
+          flatten.
+          map{|i| unhumanize_indicator(i)}.
+          each {|i| yield i }
+      end
+
+
+      # Makes human-friendly output from the indicator
+      # For example, .and()
+      def humanize_indicator indicator
+        return indicator if String === indicator
+        functor, arity = indicator
+        if arity > 1
+          ".#{functor}(#{ ','*(arity-2) })"
+        elsif arity == 1
+          ".#{functor}"
+        elsif arity == 0
+          ":#{functor}"
+        end
+      end
+
+      # Makes internal representation from predicate indicator
+      #
+      # For example, <tt>.and()</tt> becomes <tt>[:and,2]</tt>
+      def unhumanize_indicator indicator
+        case indicator
+        when Array
+          indicator
+        when /\A:(\w+)\z/
+          [:"#{$1}",0]
+        when /\A\w*\.(\w+)\z/
+          [:"#{$1}",1]
+        when /\A\w*\.(\w+)\(\w*((,\w*)*)\)\z/
+          [:"#{$1}",$2.count(",")+2]
+        else
+          raise ArgumentError, "invalid indicator: #{indicator.inspect}"
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/rubylog/context_modules/primitives.rb

@@ -0,0 +1,18 @@
+require 'rubylog/dsl/primitives'
+
+module Rubylog::ContextModules
+  module Primitives
+    def primitives
+      Rubylog::DSL::Primitives.new [default_subject, ::Rubylog::Variable]
+    end
+
+    def primitives_for subject
+      Rubylog::DSL::Primitives.new [subject, ::Rubylog::Variable]
+    end
+
+    def primitives_for_context
+      Rubylog::DSL::Primitives.new [::Rubylog::Context]
+    end
+
+  end
+end

data/lib/rubylog/context_modules/thats.rb

@@ -0,0 +1,13 @@
+require 'rubylog/dsl/thats'
+
+module Rubylog::ContextModules
+  module Thats
+    def thats
+      Rubylog::DSL::Thats.new
+    end
+
+    def thats_not
+      Rubylog::DSL::Thats::Not.new
+    end
+  end
+end

data/lib/rubylog/default_context.rb

@@ -0,0 +1,9 @@
+module Rubylog
+  DefaultContext = Object.new
+
+  # create the context
+  class << DefaultContext
+    include Rubylog::Context
+  end
+
+end

data/lib/rubylog/dsl/array_splat.rb

@@ -9,11 +9,19 @@ class Rubylog::DSL::ArraySplat
   end
 
   def inspect
-    "*#{var}"
+    "*#{var.inspect}"
   end
 
-  # CompositeTerm methods
-  include Rubylog::CompositeTerm
+  def eql? other
+    self.class == other.class && @var.eql?(other.var)
+  end
+
+  def == other
+    self.class == other.class && @var == other.var
+  end
+
+  # CompoundTerm methods
+  include Rubylog::CompoundTerm
 
   def rubylog_clone &block
     block[Rubylog::DSL::ArraySplat.new(@var.rubylog_clone(&block))]

data/lib/rubylog/dsl/primitives.rb

@@ -1,17 +1,29 @@
-class Rubylog::DSL::Primitives
-  def initialize theory
-    @theory = theory
-  end
+module Rubylog
+  class DSL::Primitives
+    def initialize subject
+      @subject = subject
+    end
+
+
+    def singleton_method_added name
+      unless name == :singleton_method_added
+        m = method(name)
 
-  def singleton_method_added name
-    unless name == :singleton_method_added
-      m = method(name)
-      @theory.functor name unless m.arity.zero?
-      @theory[[name, m.arity]] = m
+        predicate = Rubylog::Primitive.new(name, m)
+
+        # nullary predicate
+        if m.arity.zero?
+          Rubylog::NullaryPredicates[name] = predicate
+        else
+          predicate.add_functor_to(@subject)
+        end
+      end
     end
-  end
 
-  def inspect
-    "primitives"
+    def inspect
+      if @subject
+        "primitives_for(#{@subject.inspect})"
+      end
+    end
   end
 end

data/lib/rubylog/dsl/thats.rb

@@ -20,3 +20,9 @@ class Rubylog::DSL::Thats < BasicObject
     end
   end
 end
+
+class Rubylog::DSL::Thats::Not < Rubylog::DSL::Thats
+  def rubylog_matches_as_guard? other
+    not super
+  end
+end

data/lib/rubylog/dsl/variables.rb

@@ -1,30 +1,65 @@
-module Rubylog::DSL::Variables
-  def self.included mod
-    def mod.const_missing c
-      # different semantics in native blocks than otherwise
-      # @see Proc#call_with_rubylog_variables
-      if vars = Thread.current[:rubylog_current_variables]
-        # in native blocks
+require 'rubylog/variable'
 
-        # find the appropriate variable name
-        var = vars.find{|v|v.name == c}
+module Rubylog::DSL
+  # When included to a module, defines const_missing. This method creates a new
+  # variable automatically, but if a variable with that name
+  # exists in the current dynamic context, returns its deeply dereferenced
+  # value.
+  #
+  # For example,
+  #     
+  #     A                   # => A
+  #
+  # In blocks, variables are substituted with the deeply dereferenced value:
+  #
+  #     A.is(5).map{A}                       # => [5]
+  #     B.is(5).and(A.is([2,B])).map{A}      # => [[2,5]]
+  #
+  # When variables do not have a value, it is not substituted.
+  #
+  #     A.is(B).map{A}                       # => [B]
+  #     B.is(C).and(A.is([2,B])).map{A}      # => [[2,C]]
+  #     A.is([B]).map{A}                     # => [[B]]
+  #
+  # @see Proc#call_with_rubylog_variables
+  module Variables
+    def self.included mod
 
-        # return new variable if not found (probably the user wants to start using a new
-        # one)
-        return Rubylog::Variable.new c unless var
+      def mod.const_missing c
+        if vars = Thread.current[:rubylog_current_variables]
+          # in native blocks
 
-        # dereference it
-        result = var.rubylog_deep_dereference
+          # find the appropriate variable name
+          var = vars.find{|v|v.name == c}
 
-        # return nil if not bound
-        return nil if result.is_a? Rubylog::Variable 
+          # return new variable if not found (most probably the user wants to start using a new
+          # one)
+          return Rubylog::Variable.new c unless var
 
-        # return the value
-        result
-      else
-        Rubylog::Variable.new c
+          # dereference it
+          result = var.rubylog_deep_dereference
+
+          # return the value
+          result
+        else
+          Rubylog::Variable.new c
+        end
+      end
+
+      # Call the given block with variables substituted with their 
+      def self.with_vars vars
+        begin
+          old_vars = Thread.current[:rubylog_current_variables]
+          if old_vars
+            Thread.current[:rubylog_current_variables] = vars + old_vars
+          else
+            Thread.current[:rubylog_current_variables] = vars
+          end
+          yield
+        ensure
+          Thread.current[:rubylog_current_variables] = old_vars
+        end
       end
     end
   end
 end
-

data/lib/rubylog/errors.rb

@@ -1,35 +1,46 @@
 module Rubylog
+
   class RubylogError < StandardError 
-  end
-  
-  class SyntaxError < RubylogError
-  end
+    def initialize *args
+      super
 
-  class DiscontiguousPredicateError < RubylogError
-  end
+      remove_internal_lines
+    end
 
-  class MultitheoryError < RubylogError
+    def remove_internal_lines
+      internal_dir = File.dirname(__FILE__) or return
+      return unless backtrace
+      index = backtrace.index{|l| not l.start_with?(internal_dir) } or return
+      set_backtrace backtrace[index..-1]
+    end
   end
-
-  class BuiltinPredicateError < RubylogError
+  
+  class SyntaxError < RubylogError
   end
 
   class ExistenceError < RubylogError
+    def initialize clause
+      super "Predicate #{clause.inspect} does not exist"
+    end
   end
 
   class InvalidStateError < RubylogError
   end
 
   class InstantiationError < RubylogError
-  end
-
-  class TypeError < RubylogError
-  end
-
-  class UnknownVariableError < RubylogError
+    def initialize functor, args=nil
+      if args
+        super "Instantiation error in #{args[0].inspect}.#{functor}(#{args[1..-1].map{|a|a.rubylog_deep_dereference.inspect}.join(", ")})"
+      else
+        super "Instantiation error in #{functor.inspect}"
+      end
+    end
   end
 
   class CheckFailed < StandardError
+    def initialize goal
+      super "Check failed #{goal.inspect}"
+    end
   end
 
 end

data/lib/rubylog/mixins/array.rb

@@ -1,100 +1,131 @@
-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
+require 'rubylog/dsl/array_splat'
 
 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?
+    case
+
+    when ! other.is_a?(Array)
+      # [...] = 1
+      return super{yield} 
+
+    when empty? 
+      case 
+      when other.empty? 
+        # if [] = []
+        # then true
         yield
-      elsif other[0].is_a? Rubylog::DSL::ArraySplat
-        other[0].var.rubylog_unify [] do
+      when other[0].is_a?(Rubylog::DSL::ArraySplat)
+        # if [] = [*A,...]
+        # then [] = A, []=[...]
+        [].rubylog_unify other[0].var do
           self.rubylog_unify other[1..-1] do
             yield
           end
         end
       else
-        # failed
+        # fail
       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
+
+    when self[0].is_a?(Rubylog::DSL::ArraySplat)
+      # if [*A,...] = [...]
+      case
+      when other.empty?
+        # [*A,...] = []
+        self[0].var.rubylog_unify [] do
+          self[1..-1].rubylog_unify [] do
+            yield
+          end
+        end
+      when other[0].is_a?(Rubylog::DSL::ArraySplat )
+        # [*A,...] = [*B,...]
+        case 
+        when self.length == 1 && other.length == 1
+          # if [*A] = [*B]
+          # then A=B
           self[0].var.rubylog_unify other[0].var do
             yield
           end
-          return
+        when self.length == 1
+          # if [*A] = [*B,...]
+          # then A=[...]
+          self[0].var.rubylog_unify other do
+            yield
+          end
+          # TODO: we can also optimize ends of arrays.
+        else
+          # this may lead to infinite loop if variables are unbound
+          # TODO: Maybe an InstantiationError may be better.
+          # if [*A,...] = [*B,...]
+          # then eiter A=[], [...]=[*B,...]
+          self[0].var.rubylog_unify [] do
+            self[1..-1].rubylog_unify other do
+              yield
+            end
+          end
+          # or A=[H,*T], [H,*T,...]=[*B,...]
+          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
+
         end
 
+      else
+        # if [*A,...] = [X,...]
+        # then eiter A=[], [...]=[X,...]
         self[0].var.rubylog_unify [] do
           self[1..-1].rubylog_unify other do
             yield
           end
         end
+        # or A=[H,*T], [H,*T,...]=[X,...]
         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
+
+    else
+      # if [H,...]
+      case
+      when other.empty?
+        # [H,...] = []
+        # fail
+      when other[0].is_a?(Rubylog::DSL::ArraySplat)
+        # [H,...] = [*A,...]
+        # either []=A, [H,...]=[...]
+        [].rubylog_unify other[0].var do
+          self.rubylog_unify other[1..-1] do
+            yield
           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
+        # or A=[X,*R], [H,...]=[X,*R,...]
+        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
-        else
-          return if other.empty?
-          self[0].rubylog_unify other[0] do
-            self[1..-1].rubylog_unify other[1..-1] do
-              yield
-            end
+        end
+      else
+        # if [H,...]=[X,...]
+        # then H=X, [...]=[...]
+        self[0].rubylog_unify other[0] do
+          self[1..-1].rubylog_unify other[1..-1] do
+            yield
           end
         end
       end
     end
   end
 
-  # CompositeTerm methods
-  include Rubylog::CompositeTerm
+  # CompoundTerm methods
+  include Rubylog::CompoundTerm
   def rubylog_clone &block
     block[map{|t|t.rubylog_clone &block}]
   end
@@ -104,9 +135,11 @@ class Array
       case t
       when Rubylog::DSL::ArraySplat
         v = t.var.rubylog_dereference
-        if v.is_a? Array
+        if v.is_a?(Array)
+          # if it could be resolved
           v.rubylog_deep_dereference
         else
+          # if it is still a variable
           [t]
         end
       else