rubylog 0.0.1 → 1.0.0

data/examples/primitives.rb

@@ -0,0 +1,24 @@
+$:.unshift File.dirname(__FILE__)+"/../lib"
+require 'rubylog'
+
+Rubylog.theory "Try" do
+  subject String
+
+  def primitives.hello
+    puts "Hello"
+    yield
+  end
+
+  def primitives.hello x
+    puts "Hello #{x.rubylog_deep_dereference}!"
+    yield
+  end
+
+  :hello_world.if "World".hello
+
+end
+
+
+p Try.prove :hello
+p Try.prove :hello_world
+p Try.prove{X.is("World").and X.hello}

data/examples/theory.rb

@@ -1,20 +1,32 @@
+$:.unshift File.dirname(__FILE__)+"/../lib"
 require 'rubylog'
 
-class << AccessControlTheory = Rubylog::Theory.new
-  U.can_access_model(M).
-    if U.cannot_access_model(M).then :cut.and :fail
-  U.can_access_model(M).if M.is(Conversation).and {|u,m|m.users.include? u}
+class User
+  attr_accessor :favorite, :possessions
 
-  private
+  def initialize favorite, possessions
+    @favorite, @possessions = favorite, possessions
+  end
+end
 
-  U.cannot_access_model(M).if U.banned
-  U.banned.if {|u| !u.active?}
+Rubylog.theory "LikingTheory" do
+  functor :likes
+  U.likes(D).if {U.favorite == D}
+end
 
+Rubylog.theory "HavingTheory" do
+  functor :has
+  U.has(D).if {U.possessions.include? D}
 end
 
-class User
-  include_theory AccessControlTheory
+Rubylog.theory "DrinkingTheory" do
+  functor :drinks
+  include LikingTheory, HavingTheory
+  subject User
 
+  U.drinks(D).if U.likes(D).and U.has(D)
 end
 
-
+joe = User.new :beer, [:water, :beer]
+p DrinkingTheory.true? joe.drinks :water # false
+p DrinkingTheory.true? joe.drinks :beer # true

data/lib/rubylog/builtins/default.rb

@@ -0,0 +1,10 @@
+# Includes every builtin library required. +logic+ and +term+ builtins are
+# included by default.
+Rubylog.theory "Rubylog::DefaultBuiltins", nil do
+end
+
+require File.dirname(__FILE__)+"/logic"
+require File.dirname(__FILE__)+"/term"
+
+
+

data/lib/rubylog/builtins/file_system.rb

@@ -0,0 +1,15 @@
+theory "Rubylog::FileSystemBuiltins", nil do
+  subject String
+  functor :filename_in, :dirname_in, :file_in, :dir_in
+  
+  X.filename_in(D).if Y.file_in(D).and X.is { File.basename Y }
+  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

@@ -0,0 +1,109 @@
+Rubylog.theory "Rubylog::NullaryLogicBuiltins", nil do
+  class << primitives
+    # true
+    def true
+      yield
+    end
+
+    # fail
+    def fail
+    end
+
+    # !
+    def cut!
+      yield
+      throw :cut
+    end
+  end
+end
+
+Rubylog.theory "Rubylog::LogicBuiltinsForCallable", nil do
+  subject ::Rubylog::Callable, ::Rubylog::Structure, Symbol, Proc
+
+  class << primitives
+    # Succeeds if both +a+ and +b+ succeeds.
+    def and a, b
+      a.prove { b.prove { yield } }
+    end
+
+    # Succeeds if either +a+ or +b+ succeeds.
+    def or a, b
+      a.prove { yield }
+      b.prove { yield }
+    end
+
+    # Succeeds if +a+ does not succeed.
+    def false a
+      a.prove { return }
+      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.
+    def all a,b
+      a.prove {
+        stands = false; 
+        b.prove { stands = true; break } 
+        return if not stands
+      }
+      yield
+    end
+
+    # Equivalent with +a.all(b).and b.all(a)+
+    def iff a,b
+      all(a,b) { all(b,a) { yield } }
+    end
+
+    # 
+    def any a,b
+      a.prove { b.prove { yield; return } }
+    end
+
+    def one a,b
+      stands = false
+      a.prove { 
+        b.prove {
+          return if stands
+          stands = true
+        } 
+      }
+      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
+      }
+      yield if stands
+    end
+    
+    alias none false
+
+  end
+
+  prefix_functor :all, :any, :one, :none, :iff
+
+end
+
+Rubylog.theory "Rubylog::LogicBuiltins", nil do
+  include Rubylog::NullaryLogicBuiltins
+  include Rubylog::LogicBuiltinsForCallable
+end
+
+Rubylog::DefaultBuiltins.amend do
+  include Rubylog::LogicBuiltins
+end
+

data/lib/rubylog/builtins/reflection.rb

@@ -0,0 +1,94 @@
+Rubylog.theory "Rubylog::ReflectionBuiltinsForStructure", nil do
+  subject Rubylog::Structure
+
+  class << primitives
+
+    # Succeeds if +c+ is a structure, with functor +fct+ and arguments +args+
+    def structure c, fct, args
+      c = c.rubylog_dereference
+      if c.is_a? Rubylog::Variable
+        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 }
+      elsif c.is_a? Rubylog::Structure
+        c.functor.rubylog_unify fct do
+          c.args.rubylog_unify args do
+            yield
+          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
+
+    # Succeeds if +head+ unifies with a fact.
+    def fact head
+      head = head.rubylog_dereference
+      raise Rubylog::InstantiationError, 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
+          end
+        end
+      end
+    end
+    
+    # Succeeds if +head+ unifies with a rule's head and +body+ unifies with
+    # 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
+            end
+          end
+        end
+      end
+    end
+
+    # Succeeds if +a+ unifies with a variable by the name +name+ in the variable binding
+    # context of +name+.
+    # 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
+      #vars.find
+    #end
+  end
+end
+Rubylog.theory "Rubylog::ReflectionBuiltins", nil do
+  include Rubylog::ReflectionBuiltinsForStructure
+end
+
+Rubylog::DefaultBuiltins.amend do
+  include Rubylog::ReflectionBuiltins
+end

data/lib/rubylog/builtins/term.rb

@@ -0,0 +1,47 @@
+Rubylog.theory "Rubylog::TermBuiltins", nil do
+  subject ::Rubylog::Term
+
+  class << primitives
+    # = is
+    def is a,b
+      a = a.rubylog_resolve_function
+      b = b.rubylog_resolve_function
+      a.rubylog_unify(b) { yield }
+    end
+
+    def is_not a,b
+      a = a.rubylog_resolve_function
+      b = b.rubylog_resolve_function
+      a.rubylog_unify(b) { return }
+      yield
+    end
+
+    # member
+    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
+            }
+          }
+        }
+      else
+        b.each do |e|
+          a.rubylog_unify(e) { yield }
+        end
+      end
+    end
+
+    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/dsl/array_splat.rb

@@ -0,0 +1,25 @@
+# this class is used as a placeholder for array splats.
+# [*A] => [ArraySplat.new(A)]
+class Rubylog::DSL::ArraySplat
+
+  attr_reader :var
+
+  def initialize var = Rubylog::Variable.new
+    @var = var
+  end
+
+  def inspect
+    "*#{var}"
+  end
+
+  # CompositeTerm methods
+  include Rubylog::CompositeTerm
+
+  def rubylog_clone &block
+    block[Rubylog::DSL::ArraySplat.new(@var.rubylog_clone(&block))]
+  end
+
+  def rubylog_deep_dereference
+    Rubylog::DSL::ArraySplat.new(@var.rubylog_deep_dereference)
+  end
+end

data/lib/rubylog/dsl/primitives.rb

@@ -0,0 +1,17 @@
+class Rubylog::DSL::Primitives
+  def initialize theory
+    @theory = theory
+  end
+
+  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
+    end
+  end
+
+  def inspect
+    "primitives"
+  end
+end

data/lib/rubylog/dsl/thats.rb

@@ -0,0 +1,22 @@
+class Rubylog::DSL::Thats < BasicObject
+  def method_missing *msg
+    @messages ||= []
+    @messages << msg
+    self
+  end
+
+  def rubylog_matches_as_guard? other
+    @messages.inject(other) {|o,msg|o.send *msg}
+  end
+  
+  def == *msg
+    method_missing :==, *msg
+  end
+
+  debug = true
+  if debug
+    def inspect
+      @messages
+    end
+  end
+end

data/lib/rubylog/dsl/variables.rb

@@ -0,0 +1,30 @@
+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
+
+        # find the appropriate variable name
+        var = vars.find{|v|v.name == c}
+
+        # return new variable if not found (probably the user wants to start using a new
+        # one)
+        return Rubylog::Variable.new c unless var
+
+        # dereference it
+        result = var.rubylog_deep_dereference
+
+        # return nil if not bound
+        return nil if result.is_a? Rubylog::Variable 
+
+        # return the value
+        result
+      else
+        Rubylog::Variable.new c
+      end
+    end
+  end
+end
+

data/lib/rubylog/dsl.rb

@@ -1,52 +1,70 @@
 module Rubylog::DSL
-  def self.add_first_order_functor *fs
-    add_functors_to FirstOrderFunctors, *fs
-  end
-
-  def self.add_second_order_functor *fs
-    add_functors_to SecondOrderFunctors, *fs
-  end
-
   def self.add_functors_to class_or_module, *functors
     functors.each do |f|
       m = functor_module(f)
       class_or_module.send :include, m
       Rubylog::Variable.send :include, m
-      add_global_functor f
     end
   end
+
   
   @functor_modules ||= {}
 
+  def self.normalize_functor fct
+    case s = fct.to_s
+    when /[?!]\z/ then :"#{s[0...-1]}" 
+    when /=\z/ then nil
+    else fct
+    end
+  end
+
   def self.functor_module f
     @functor_modules[f] ||= Module.new do
       define_method f do |*args, &block|
         args << block if block
-        Rubylog::Clause.new f, self, *args 
+        Rubylog::Structure.new f, self, *args 
       end
 
       f_bang =  :"#{f}!"
       define_method f_bang do |*args, &block|
         args << block if block
-        Rubylog.theory.assert Rubylog::Clause.new(f, self, *args), :true
+        Rubylog.current_theory.assert Rubylog::Structure.new(f, self, *args), :true
         self
       end
 
       f_qmark = :"#{f}?"
       define_method f_qmark do |*args, &block|
         args << block if block
-        Rubylog.theory.true? Rubylog::Clause.new(f, self, *args)
+        Rubylog.current_theory.true? Rubylog::Structure.new(f, self, *args)
       end
     end
   end
 
-  protected 
+  def self.add_prefix_functors_to class_or_module, *functors
+    functors.each do |f|
+      class_or_module.class_eval do
+        define_method f do |*args, &block|
+          args << block if block
+          Rubylog::Structure.new f, *args 
+        end
+
+        f_bang =  :"#{f}!"
+        define_method f_bang do |*args, &block|
+          args << block if block
+          # TODO consider self.assert
+          Rubylog.current_theory.assert Rubylog::Structure.new(f, *args), :true
+          self
+        end
 
-  def self.add_global_functor f
-    GlobalFunctors.send :define_method, f do |*args, &block|
-      args << block if block
-      Rubylog::Clause.new f, *args 
+        f_qmark = :"#{f}?"
+        define_method f_qmark do |*args, &block|
+          args << block if block
+          #TODO consider self.true?
+          Rubylog.current_theory.true? Rubylog::Structure.new(f, *args)
+        end
+      end
     end
   end
+
 end
 

data/lib/rubylog/errors.rb

@@ -1,8 +1,14 @@
 module Rubylog
   class RubylogError < StandardError 
   end
+  
+  class SyntaxError < RubylogError
+  end
+
+  class DiscontiguousPredicateError < RubylogError
+  end
 
-  class DiscontinuousPredicateError < RubylogError
+  class MultitheoryError < RubylogError
   end
 
   class BuiltinPredicateError < RubylogError
@@ -14,5 +20,17 @@ module Rubylog
   class InvalidStateError < RubylogError
   end
 
+  class InstantiationError < RubylogError
+  end
+
+  class TypeError < RubylogError
+  end
+
+  class UnknownVariableError < RubylogError
+  end
+
+  class CheckFailed < StandardError
+  end
+
 end
 

data/lib/rubylog/interfaces/assertable.rb

@@ -0,0 +1,16 @@
+module Rubylog::Assertable
+  def if body=nil, &block
+    raise Rubylog::SyntaxError, "No body given", caller unless body || block
+    Rubylog.current_theory.assert self, body || block
+  end
+
+  def if! body=nil, &block
+    raise Rubylog::SyntaxError, "No body given", caller unless body || block
+    Rubylog.current_theory.assert self, Rubylog::Structure.new(:and, :cut!, body || block)
+  end
+
+  def unless body=nil, &block
+    raise Rubylog::SyntaxError, "No body given", caller unless body || block
+    Rubylog.current_theory.assert self, Rubylog::Structure.new(:false, body || block)
+  end
+end

data/lib/rubylog/interfaces/callable.rb

@@ -0,0 +1,18 @@
+module Rubylog::Callable
+  # should yield for each possible solution of the term
+  #def prove
+  #  raise "abstract method called"
+  #end
+
+  def true?
+    Rubylog.current_theory.true? self
+  end
+
+  def solve
+    if block_given?
+      Rubylog.current_theory.solve(self) {|*a| yield *a}
+    else
+      Rubylog.current_theory.solve(self) {|*a|}
+    end
+  end
+end

data/lib/rubylog/interfaces/composite_term.rb

@@ -0,0 +1,47 @@
+module Rubylog::CompositeTerm
+  def rubylog_compile_variables 
+    vars = []; vars_by_name = {}
+    rubylog_clone do |subterm|
+      case subterm
+      when Rubylog::Variable
+        var = subterm
+
+        if var.dont_care?
+          var.dup
+        else
+          new_var = vars_by_name[var.name]
+          if new_var
+            new_var.guards = new_var.guards + var.guards
+            new_var
+          else
+            new_var = var.dup
+            vars << new_var
+            vars_by_name[var.name] = new_var
+            new_var
+          end
+        end
+
+      when Rubylog::CompositeTerm
+        subterm.instance_variable_set :"@rubylog_variables", vars
+        subterm
+      else
+        subterm
+      end
+    end
+  end
+
+  #should return a copy with rubylog_deep_dereference called for sub-terms
+  #def rubylog_deep_dereference
+    #self.class.new attr1.rubylog_deep_dereference
+  #end
+
+  attr_reader :rubylog_variables
+
+
+  # This is a general deep-copy generating method
+  # should return a deep copy of the term, atomic terms treated as
+  # leaves, with &block called post-order
+  #def rubylog_clone &block
+    #block.call self.class.new attr1.rubylog_clone &block
+  #end
+end

data/lib/rubylog/interfaces/predicate.rb

@@ -0,0 +1,8 @@
+module Rubylog::Predicate
+  # should yield iff the predicate is solvable eg.
+  # def call
+  #   ...
+  #   yield if ...
+  #   ...
+  # end
+end