rubylog 1.0.0 → 2.0pre1

data/lib/rubylog/assertable.rb

@@ -0,0 +1,24 @@
+module Rubylog::Assertable
+  # Asserts a rule with the receiver as the head and the given argument or
+  # block as the body to the head's predicate.
+  def if body=nil, &block
+    raise Rubylog::SyntaxError, "No body given", caller unless body || block
+    predicate.assert(self, body || block)
+  end
+
+  # Asserts a rule with the receiver as the head and the given argument or
+  # block as the body to the head's predicate. Prepends a :cut! in front of the
+  # body with and .and().
+  #
+  def if! body=nil, &block
+    raise Rubylog::SyntaxError, "No body given", caller unless body || block
+    predicate.assert self, :cut!.and(body || block)
+  end
+
+  # Asserts a rule with the receiver as the head and the given argument or
+  # block as the body to the head's predicate. Adds a .false to the body.
+  def unless body=nil, &block
+    raise Rubylog::SyntaxError, "No body given", caller unless body || block
+    predicate.assert self, Rubylog::DefaultContext.false(body || block)
+  end
+end

data/lib/rubylog/builtins/arithmetics.rb

@@ -0,0 +1,63 @@
+rubylog do
+
+  class << primitives_for Numeric
+    # Succeeds if +c+ unifies with the sum of +a+ and +b+ if +a+ and +b+ is given.
+    # Succeeds if +a+ unifies with the difference of +c+ and +b+ if +c+ and +b+ is given.
+    # Succeeds if +b+ unifies with the difference of +c+ and +a+ if +c+ and +a+ is given.
+    #
+    # +a+ and +b+ can be procs.
+    #
+    # Please beware that unification requires equality by type, so 4.sum_of(2, 2.0) will fail.
+    #
+    # It can add any type of object that responds_to + and/or -:
+    #     A.sum_of(B,C).predicate.add_functor_to String
+    #     check "hello".sum_of("he", "llo")
+    #
+    def sum_of c, a, b
+      a, b, c = [a,b,c].map{|f|f.rubylog_resolve_function.rubylog_dereference}
+      a_var, b_var, c_var = [a,b,c].map{|f|f.is_a? Rubylog::Variable}
+
+      case
+      when !a_var && !b_var
+        c.rubylog_unify(a+b) { yield }
+      when !c_var && !b_var
+        a.rubylog_unify(c-b) { yield }
+      when !c_var && !a_var
+        b.rubylog_unify(c-a) { yield }
+      else
+        raise Rubylog::InstantiationError.new :sum_of, [c, a, b]
+      end
+
+    end
+
+    # Succeeds if +c+ unifies with the product of +a+ and +b+ if +a+ and +b+ is given.
+    # Succeeds if +a+ unifies with the difference of +c+ and +b+ if +c+ and +b+ is given.
+    # Succeeds if +b+ unifies with the difference of +c+ and +a+ if +c+ and +a+ is given.
+    #
+    # +a+ and +b+ can be procs.
+    #
+    # Please beware that unification requires equality by type, so 4.sum_of(2, 2.0) will fail.
+    #
+    # It can add any type of object that responds_to + and/or -:
+    #     A.sum_of(B,C).predicate.add_functor_to String
+    #     check "hello".sum_of("he", "llo")
+    #
+    def product_of c, a, b
+      a, b, c = [a,b,c].map{|f|f.rubylog_resolve_function.rubylog_dereference}
+      a_var, b_var, c_var = [a,b,c].map{|f|f.is_a? Rubylog::Variable}
+
+      case
+      when !a_var && !b_var
+        c.rubylog_unify(a*b) { yield }
+      when !c_var && !b_var
+        a.rubylog_unify(c/b) { yield } if ((c/b)*b).eql? c
+      when !c_var && !a_var
+        b.rubylog_unify(c/a) { yield } if (a*(c/a)).eql? c
+      else
+        raise Rubylog::InstantiationError.new :product_of, [c, a, b]
+      end
+
+    end
+  end
+end
+

data/lib/rubylog/builtins/assumption.rb

@@ -0,0 +1,71 @@
+rubylog do
+  predicate_for ::Rubylog::Assertable, ".assumed", ".rejected", ".revoked", ".assumed_if()", ".assumed_unless()", ".rejected_if()", ".rejected_unless()"
+
+  # Asserts a rule with head H and body B in the predicate of H. It retracts it
+  # at backtracking.
+  H.assumed_if(B).if proc {
+    raise Rubylog::InstantiationError.new :assumed_if, [H, B] if !H or !B
+
+    # assert
+    H.predicate.unshift Rubylog::Rule.new(H, B)
+    
+    true
+  }.ensure {
+    # retract
+    H.predicate.shift
+  }
+
+  # Asserts a fact A to the predicate of A.
+  # The clause is retracted at backtracking.
+  A.assumed.if A.assumed_if :true
+
+  # Asserts a rule H.if(B.false) in the predicate of H.
+  # The clause is retracted at backtracking.
+  H.assumed_unless(B).if H.assumed_if(B.false)
+
+  # Asserts a rule A.if(:cut!.and(:fail)) in the predicate of A.
+  # The clause is retracted at backtracking.
+  A.rejected.if A.assumed_if :cut!.and :fail
+
+  # Asserts a rule H.if(B.and :cut!.and(:fail)) in the predicate of H.
+  # The clause is retracted at backtracking.
+  H.rejected_if(B).if H.assumed_if(B.and :cut!.and :fail)
+
+  # Asserts a rule H.if(B.false.and :cut!.and(:fail)) in the predicate of H.
+  # The clause is retracted at backtracking.
+  H.rejected_unless(B).if H.assumed_if(B.false.and :cut!.and :fail)
+
+
+
+  class << primitives_for ::Rubylog::Assertable
+    # Retracts a rule from the predicate of +h+. At backtracking, the rule is
+    # re-asserted.  It consequently succeeds with each rule in the predicate
+    # retracted.    
+    #
+    def revoked h
+      h = h.rubylog_dereference
+      raise Rubylog::InstantiationError.new :revoked, [h] if h.is_a? Rubylog::Variable
+
+      predicate = h.predicate
+
+      (0...predicate.size).each do |i|
+        # retract the clause
+        r = predicate.delete_at(i)
+        begin
+          rule = r.rubylog_match_variables
+          rule.head.args.rubylog_unify h.args do
+            rule.body.prove do
+              yield
+            end
+          end
+        ensure
+          # re-assert the clause
+          predicate.insert(i, r)
+        end
+      end
+    end
+  end
+
+
+end
+

data/lib/rubylog/builtins/ensure.rb

@@ -0,0 +1,13 @@
+rubylog do
+  
+  class << primitives_for ::Rubylog::Clause
+    # succeeds if A succeeds. At backtracking, solves B
+    def ensure a, b
+      begin
+        a.prove { yield }
+      ensure
+        b.prove {}
+      end
+    end
+  end
+end

data/lib/rubylog/builtins/file_system.rb

@@ -1,15 +1,37 @@
-theory "Rubylog::FileSystemBuiltins", nil do
-  subject String
-  functor :filename_in, :dirname_in, :file_in, :dir_in
+rubylog do
+  predicate_for String, ".filename_in()", ".dirname_in()", ".file_in()", ".dir_in()"
   
+  # If D is not a variable, succeeds if D is a name of an existing directory and 
+  # X unifies with a file in directory D. X necessarily starts with # "#{D}/".
+  # Either X or D must be bound. X can contain variables, D cannot.
+  # If D is a variable, it is unified with the dirname of X.
+  #
+  X.file_in(D).if proc{raise Rubylog::InstantiationError.new(:file_in, [X,D]) if D.is_a?(Rubylog::Variable) && X.is_a?(Rubylog::Variable)}
+  X.file_in(D).if proc{! D.is_a?(Rubylog::Variable)}.and X.in { 
+    d = D.rubylog_resolve_function
+    Dir["#{d}/*", "#{d}/.*"].sort.select{|x| 
+      # exclude . and ..
+      File.basename(x) !~ /\A\.\.?\z/ 
+    }
+  }
+  X.file_in(D).if proc{! X.is_a? Rubylog::Variable and File.exist?(X)}.and D.is { File.dirname(X) }
+
+  # If D is not a variable, succeeds if X unifies with a directory in directory D. X
+  # necessarily starts with "#{D}/". X can contain variables, D cannot.
+  # If D is a variable, it is unified with the dirname of X.
+  #
+  X.dir_in(D). if X.file_in(D).and { File.directory? X }
+
+  # If D is not a variable, succeeds if X unifies with a name of a file in directory D.
+  # X can contain variables, D cannot. If D is a variable, it is unified with the dirname of X.
+  #
   X.filename_in(D).if Y.file_in(D).and X.is { File.basename Y }
+
+  # If D is not a variable, succeeds if X unifies with a name of a directory in directory D.
+  # X can contain variables, D cannot. If D is a variable, it is unified with the dirname of X.
+  #
   X.dirname_in(D).if  Y.dir_in(D).and  X.is { File.basename Y }
-  X.file_in(D).if Y.in { d = D.rubylog_resolve_function; Dir["#{d}/*", "#{d}/.*"].sort }.and { not ['.','..'].include? File.basename(Y) and not File.directory? Y }.and X.is {File.expand_path Y}
-  X.dir_in(D). if Y.in { d = D.rubylog_resolve_function; Dir["#{d}/*", "#{d}/.*"].sort }.and { not ['.','..'].include? File.basename(Y) and     File.directory? Y }.and X.is {File.expand_path Y}
 
 end
 
 
-Rubylog::DefaultBuiltins.amend do
-  include Rubylog::FileSystemBuiltins
-end

data/lib/rubylog/builtins/logic.rb

@@ -1,4 +1,4 @@
-Rubylog.theory "Rubylog::NullaryLogicBuiltins", nil do
+rubylog do
   class << primitives
     # true
     def true
@@ -15,12 +15,11 @@ Rubylog.theory "Rubylog::NullaryLogicBuiltins", nil do
       throw :cut
     end
   end
-end
 
-Rubylog.theory "Rubylog::LogicBuiltinsForCallable", nil do
-  subject ::Rubylog::Callable, ::Rubylog::Structure, Symbol, Proc
 
-  class << primitives
+  primitives_for_clause = primitives_for [::Rubylog::Clause, ::Rubylog::Structure]
+
+  class << primitives_for_clause
     # Succeeds if both +a+ and +b+ succeeds.
     def and a, b
       a.prove { b.prove { yield } }
@@ -34,14 +33,18 @@ Rubylog.theory "Rubylog::LogicBuiltinsForCallable", nil do
 
     # Succeeds if +a+ does not succeed.
     def false a
-      a.prove { return }
+      # catch cuts
+      catch :cut do
+        a.prove { return }
+      end
       yield
     end
 
     # ruby iterator predicate allegories
 
-    # For each successful execution of +a+, executes +b+. If any of +b+'s
-    # executions fails, it fails, otherwise it succeeds.
+    # Succeeds if for each successful execution of +a+, there exists a solution of +b+.
+    #
+    # Equivalent with <tt>a.and(b.false).false</tt>
     def all a,b
       a.prove {
         stands = false; 
@@ -51,17 +54,26 @@ Rubylog.theory "Rubylog::LogicBuiltinsForCallable", nil do
       yield
     end
 
-    # Equivalent with +a.all(b).and b.all(a)+
+    # Succeeds if a and b are equivalent statements
+    #
+    # Equivalent with <tt>a.all(b).and b.all(a)</tt>
     def iff a,b
       all(a,b) { all(b,a) { yield } }
     end
 
-    # 
-    def any a,b
+    # Succeeds if for any solution of +a+, +b+ is solveable.
+    #
+    # @param a
+    # @param b defaults to :true
+    def any a,b=:true
       a.prove { b.prove { yield; return } }
     end
 
-    def one a,b
+    # Succeeds if there exists one solution of +a+ where +b+ is true.
+    #
+    # @param a
+    # @param b defaults to :true
+    def one a,b=:true
       stands = false
       a.prove { 
         b.prove {
@@ -72,38 +84,57 @@ Rubylog.theory "Rubylog::LogicBuiltinsForCallable", nil do
       yield if stands
     end
 
-    def none a,b
-      a.prove { b.prove { return } }
-      yield 
-    end
-
-    def any a
-      a.prove { yield; return }
-    end
-
-    def one a
-      stands = false
-      a.prove { 
-        return if stands
-        stands = true
+    # For each successful solutions of +a+, tries to solve +b+. If any of +b+'s
+    # solutions succeeds, it fails, otherwise it succeeds
+    #
+    # Equivalent to <tt>a.all(b.false)</tt>
+    # @param a
+    # @param b defaults to :true
+    def none a,b=:true
+      a.prove {
+        b.prove { return } 
       }
-      yield if stands
+      yield
     end
-    
-    alias none false
 
   end
 
-  prefix_functor :all, :any, :one, :none, :iff
-
-end
+  # We also implement some of these methods in a prefix style
+  %w(false all iff any one none).each do |fct|
+    # we discard the first argument, which is the context,
+    # because they are the same in  any context
+    primitives_for_context.define_singleton_method fct do |_,*args,&block|
+      primitives_for_clause.send(fct, *args, &block)
+    end
+  end
 
-Rubylog.theory "Rubylog::LogicBuiltins", nil do
-  include Rubylog::NullaryLogicBuiltins
-  include Rubylog::LogicBuiltinsForCallable
-end
+  class << primitives_for_context
+    # finds every solution of a, and for each solution dereferences all
+    # variables in b if possible and collects the results. Then joins all b's
+    # with .and() and solves the resulted expression.
+    def every _, a, b
+      c = []
+      a.prove do
+        if b.is_a? Proc
+          # save copies of actual variables
+          vars = a.rubylog_variables.map do |v|
+            new_v = Rubylog::Variable.new(v.name)
+            new_v.send :bind_to!, v.value if v.bound?
+          end
+
+          # store them in a closure
+          b_resolved = proc do
+            b.call_with_rubylog_variables vars
+          end
+        else
+          # dereference actual variables
+          b_resolved = b.rubylog_deep_dereference 
+        end
+        c << b_resolved
+      end
+      c.inject(:true){|a,b|a.and b}.solve { yield }
+    end
+  end
 
-Rubylog::DefaultBuiltins.amend do
-  include Rubylog::LogicBuiltins
 end
 

data/lib/rubylog/builtins/reflection.rb

@@ -1,54 +1,47 @@
-Rubylog.theory "Rubylog::ReflectionBuiltinsForStructure", nil do
-  subject Rubylog::Structure
+rubylog do
 
-  class << primitives
+  class << primitives_for Rubylog::Structure
 
-    # Succeeds if +c+ is a structure, with functor +fct+ and arguments +args+
-    def structure c, fct, args
+    # Succeeds if +c+ is a structure, with predicate +predicate+, functor +fct+ and arguments +args+
+    def structure c, predicate, fct, args
       c = c.rubylog_dereference
       if c.is_a? Rubylog::Variable
+        predicate = predicate.rubylog_dereference
         fct = fct.rubylog_dereference
         args = args.rubylog_dereference
+
         # We enable variable functors
         #raise Rubylog::InstantiationError, fct if fct.is_a? Rubylog::Variable
-        raise Rubylog::InstantiationError, args if args.is_a? Rubylog::Variable
-        c.rubylog_unify(Rubylog::Structure.new(fct, *args)) { yield }
+        
+        raise Rubylog::InstantiationError.new :structure, [c, predicate, fct, args] if args.is_a? Rubylog::Variable
+
+        c.rubylog_unify(Rubylog::Structure.new(predicate, fct, *args)) { yield }
       elsif c.is_a? Rubylog::Structure
-        c.functor.rubylog_unify fct do
-          c.args.rubylog_unify args do
-            yield
+        c.predicate.rubylog_unify predicate do
+          c.functor.rubylog_unify fct do
+            c.args.rubylog_unify args do
+              yield
+            end
           end
         end
       end
     end
 
-    # I don't remember what this is supposed to be.
-    #def predicate l
-      #_functor = Rubylog::Variable.new(:_functor)
-      #_arity = Rubylog::Variable.new(:_arity)
-      #l.rubylog_unify [f, a] do
-        #if f = _functor.value
-          ## TODO
-        #else
-          ## TODO
-        #end
-      #end
-    #end
+  end
+
+  class << primitives_for [Rubylog::Assertable, ::Rubylog::Structure]
 
     # Succeeds if +head+ unifies with a fact.
     def fact head
       head = head.rubylog_dereference
-      raise Rubylog::InstantiationError, head if head.is_a? Rubylog::Variable
+      raise Rubylog::InstantiationError.new :fact, [head] if head.is_a? Rubylog::Variable
       return yield if head == :true
       return unless head.respond_to? :functor
-      predicate = Rubylog.current_theory[head.indicator]
-      if predicate.respond_to? :each # if it is a procedure
-        predicate.each do |rule|
-          if rule[1] == :true
-            rule = rule.rubylog_compile_variables
-            rule[0].args.rubylog_unify head.args do
-              yield
-            end
+      head.predicate.each do |rule|
+        if rule.body == :true
+          rule = rule.rubylog_match_variables
+          rule.head.args.rubylog_unify head.args do
+            yield
           end
         end
       end
@@ -58,17 +51,14 @@ Rubylog.theory "Rubylog::ReflectionBuiltinsForStructure", nil do
     # this rule's body.
     def follows_from head, body
       head = head.rubylog_dereference
-      raise Rubylog::InstantiationError, head if head.is_a? Rubylog::Variable
-      return unless head.respond_to? :functor
-      predicate = Rubylog.current_theory[head.indicator]
-      if predicate.respond_to? :each
-        predicate.each do |rule|
-          unless rule[1]==:true # do not succeed for facts
-            rule = rule.rubylog_compile_variables
-            rule[0].args.rubylog_unify head.args do
-              rule[1].rubylog_unify body do
-                yield
-              end
+      raise Rubylog::InstantiationError.new :follows_from, [head, body] if head.is_a? Rubylog::Variable
+      
+      head.predicate.each do |rule|
+        unless rule.body==:true # do not succeed for facts
+          rule = rule.rubylog_match_variables
+          rule.head.args.rubylog_unify head.args do
+            rule.body.rubylog_unify body do
+              yield
             end
           end
         end
@@ -80,15 +70,10 @@ Rubylog.theory "Rubylog::ReflectionBuiltinsForStructure", nil do
     # Removed because of the "every built-in prediate is pure logical" principle
     #def variable a, name
       #vars = name.rubylog_variables
-      #raise Rubylog::InvalidStateError, "variables not available" if not vars
+      #raise Rubylog::InvalidStateError, "variables not matched" if not vars
       #vars.find
     #end
-  end
-end
-Rubylog.theory "Rubylog::ReflectionBuiltins", nil do
-  include Rubylog::ReflectionBuiltinsForStructure
-end
 
-Rubylog::DefaultBuiltins.amend do
-  include Rubylog::ReflectionBuiltins
+  end
+    
 end

data/lib/rubylog/builtins/term.rb

@@ -1,14 +1,18 @@
-Rubylog.theory "Rubylog::TermBuiltins", nil do
-  subject ::Rubylog::Term
+rubylog do
 
-  class << primitives
-    # = is
+  class << primitives_for Rubylog::Term
+    # Unifies +a+ with +b+. Both can be a proc, which is then called and the result
+    # is taken.
     def is a,b
       a = a.rubylog_resolve_function
       b = b.rubylog_resolve_function
       a.rubylog_unify(b) { yield }
     end
 
+    # Unifies +a+ with +b+. Fails if the unification succeeds, otherwise succeeds.
+    #
+    # Both +a+ and +b+ can be a proc, which is then called and the result
+    # is taken.
     def is_not a,b
       a = a.rubylog_resolve_function
       b = b.rubylog_resolve_function
@@ -16,18 +20,15 @@ Rubylog.theory "Rubylog::TermBuiltins", nil do
       yield
     end
 
-    # member
+    # Unifies +a+ with each member of enumerable +b+
+    #
+    # Both +a+ and +b+ can be a proc, which is then called and the result
+    # is taken.
     def in a,b
       a = a.rubylog_resolve_function
       b = b.rubylog_resolve_function.rubylog_dereference
-      if b.instance_of? Rubylog::Variable
-        Rubylog::InternalHelpers.non_empty_list {|l|
-          a.rubylog_unify(l[-1]) {
-            b.rubylog_unify(l) {
-              yield
-            }
-          }
-        }
+      if b.is_a? Rubylog::Variable
+        raise Rubylog::InstantiationError.new :in, [a,b]
       else
         b.each do |e|
           a.rubylog_unify(e) { yield }
@@ -35,13 +36,10 @@ Rubylog.theory "Rubylog::TermBuiltins", nil do
       end
     end
 
+    # Succeeds if +a+ cannot be unified with any member of enumerable +b+.
     def not_in a, b
       self.in(a, b) { return }
       yield
     end
   end
 end
-
-Rubylog::DefaultBuiltins.amend do
-  include Rubylog::TermBuiltins
-end

data/lib/rubylog/builtins.rb

@@ -0,0 +1,11 @@
+
+require 'rubylog/builtins/logic'
+require 'rubylog/builtins/term'
+require 'rubylog/builtins/file_system'
+require 'rubylog/builtins/ensure'
+require 'rubylog/builtins/assumption'
+require 'rubylog/builtins/reflection'
+require 'rubylog/builtins/arithmetics'
+
+
+

data/lib/rubylog/clause.rb

@@ -0,0 +1,19 @@
+module Rubylog::Clause
+  # Clients should implement this method. 
+  # Yields for each possible solution of the predicate
+  def prove
+    raise "#{self.class} should implement #prove"
+  end
+
+  def true?
+    solve { return true }
+    false
+  end
+
+  def solve &block
+    goal = rubylog_match_variables 
+    catch :cut do
+      goal.prove { block.call_with_rubylog_variables(goal.rubylog_variables) if block }
+    end
+  end
+end

data/lib/rubylog/{interfaces/composite_term.rb → compound_term.rb}

@@ -1,5 +1,5 @@
-module Rubylog::CompositeTerm
-  def rubylog_compile_variables 
+module Rubylog::CompoundTerm
+  def rubylog_match_variables 
     vars = []; vars_by_name = {}
     rubylog_clone do |subterm|
       case subterm
@@ -21,7 +21,7 @@ module Rubylog::CompositeTerm
           end
         end
 
-      when Rubylog::CompositeTerm
+      when Rubylog::CompoundTerm
         subterm.instance_variable_set :"@rubylog_variables", vars
         subterm
       else

data/lib/rubylog/context.rb

@@ -0,0 +1,24 @@
+
+require 'rubylog/dsl/variables'
+require 'rubylog/context_modules/checks'
+require 'rubylog/context_modules/demonstration'
+require 'rubylog/context_modules/predicates'
+require 'rubylog/context_modules/primitives'
+require 'rubylog/context_modules/thats'
+
+# The context class represents a collection of rules.
+
+module Rubylog::Context
+
+
+  include Rubylog::ContextModules::Checks
+  include Rubylog::ContextModules::Demonstration
+  include Rubylog::ContextModules::Predicates
+  include Rubylog::ContextModules::Primitives
+  include Rubylog::ContextModules::Thats
+
+end
+
+
+
+