rubylog 0.0.0

data/lib/rubylog/clause.rb

@@ -0,0 +1,113 @@
+module Rubylog
+  class Clause
+
+    # data structure
+    attr_reader :functor, :args
+    def initialize functor, *args
+      @functor = functor
+      @args = args.freeze
+      @arity = args.count
+    end
+
+    def [] i
+      @args[i]
+    end
+
+    def == other
+      other.instance_of? Clause and
+      @functor == other.functor and @args == other.args
+    end
+    alias eql? ==
+
+    def hash
+      @functor.hash ^ @args.hash
+    end
+    
+    def inspect
+      "#{@args[0].inspect}.#{@functor}#{
+        "(#{@args[1..-1].inspect[1..-2]})" if @args.count>1
+      }"
+    end
+
+    def to_s
+      inspect
+    end
+
+    def arity
+      @arity
+    end
+
+    def desc
+      [@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
+
+
+
+    # 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
+    end
+
+    # enumerable methods
+    include Enumerable
+    alias each solve
+
+    # Unifiable methods
+    include Rubylog::Unifiable
+    def rubylog_unify other
+      return super{yield} unless other.instance_of? self.class
+      return unless other.functor == @functor
+      return unless @arity == other.arity
+      @args.rubylog_unify(other.args) { yield }
+    end
+
+    attr_reader :rubylog_variables
+
+    # CompositeTerm methods
+    include Rubylog::CompositeTerm
+    def rubylog_clone &block
+      block.call Clause.new @functor,
+        *@args.map{|a|a.rubylog_clone &block}
+    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 variable_hashes
+      rubylog_compile_variables.variable_hashes_without_compile
+    end
+
+    protected
+
+    def variable_hashes_without_compile
+      variables = rubylog_variables
+      map do |*values|
+        Hash[variables.zip values]
+      end
+    end
+  end
+
+end

data/lib/rubylog/composite_term.rb

@@ -0,0 +1,38 @@
+module Rubylog
+  module CompositeTerm
+    def rubylog_compile_variables 
+      vars = []; vars_by_name = {}
+      rubylog_clone do |i|
+        if i.is_a? Rubylog::Variable
+          if i.dont_care?
+            i = i.dup
+          else
+            i = vars_by_name[i.name] || begin
+              r = i.dup
+              vars << r
+              vars_by_name[i.name] = r
+            end
+          end
+        elsif i.is_a? Rubylog::CompositeTerm
+          i.instance_variable_set :"@rubylog_variables", vars
+        end
+        i
+      end
+    end
+
+    def rubylog_deep_dereference
+      rubylog_clone do |i|
+        i.rubylog_deep_dereference
+      end
+    end
+
+    attr_reader :rubylog_variables
+
+
+    # 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
+end

data/lib/rubylog/dsl/constants.rb

@@ -0,0 +1,15 @@
+module Rubylog
+  module DSL
+    module Constants
+      def self.included class_or_module
+        class_or_module.extend ClassMethods
+      end
+
+      module ClassMethods
+        def const_missing c
+          Rubylog::Variable.new c
+        end
+      end
+    end
+  end
+end

data/lib/rubylog/dsl/first_order_functors.rb

@@ -0,0 +1,9 @@
+module Rubylog
+  module DSL
+    module FirstOrderFunctors
+      # see rubylog/builtins.rb
+    end
+  end
+end
+      
+

data/lib/rubylog/dsl/global_functors.rb

@@ -0,0 +1,3 @@
+module Rubylog::DSL::GlobalFunctors
+
+end

data/lib/rubylog/dsl/second_order_functors.rb

@@ -0,0 +1,8 @@
+module Rubylog
+  module DSL
+    module SecondOrderFunctors
+      # see rubylog/builtins.rb
+    end
+  end
+end
+      

data/lib/rubylog/dsl.rb

@@ -0,0 +1,52 @@
+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.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 
+      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
+        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)
+      end
+    end
+  end
+
+  protected 
+
+  def self.add_global_functor f
+    GlobalFunctors.send :define_method, f do |*args, &block|
+      args << block if block
+      Rubylog::Clause.new f, *args 
+    end
+  end
+end
+

data/lib/rubylog/errors.rb

@@ -0,0 +1,18 @@
+module Rubylog
+  class RubylogError < StandardError 
+  end
+
+  class DiscontinuousPredicateError < RubylogError
+  end
+
+  class BuiltinPredicateError < RubylogError
+  end
+
+  class ExistenceError < RubylogError
+  end
+
+  class InvalidStateError < RubylogError
+  end
+
+end
+

data/lib/rubylog/internal_helpers.rb

@@ -0,0 +1,16 @@
+module Rubylog::InternalHelpers
+  class << self
+    def non_empty_list 
+      l = []
+      while true do
+        l << Rubylog::Variable.new(:_)
+        yield l
+      end
+    end
+
+    def vars_hash_of o
+      vars = o.rubylog_variables
+      Hash[vars.zip(vars.map{|v|v.value})]
+    end
+  end
+end

data/lib/rubylog/predicate.rb

@@ -0,0 +1,34 @@
+
+module Rubylog
+  class Predicate < Array
+    # accepts the *args of the called clause
+    def call *args
+      begin
+        each do |rule|
+          rule = rule.rubylog_compile_variables
+          head, body = rule[0], rule[1]
+          head.args.rubylog_unify(args) { 
+            Rubylog.theory.trace 1, head, InternalHelpers.vars_hash_of(head)
+            body.prove { 
+              yield 
+            }
+            Rubylog.theory.trace -1
+          }
+        end
+      rescue Cut
+      end
+    end
+
+    def discontinuous!
+      @discontinuous = true
+    end
+
+    def discontinuous?
+      @discontinuous
+    end
+
+  end
+  
+
+
+end

data/lib/rubylog/proc_method_additions.rb

@@ -0,0 +1,69 @@
+module Rubylog
+  module ProcMethodAdditions
+
+    # Procs and methods are used three ways. 
+    #
+    # Firstly, as a predicate. A predicate is an object that responds to #call,
+    # and yields if and the number of times the represented predicate is
+    # provable. Built-in predicates are implemented this way.
+    # Example (definition of a new built-in twice): 
+    #   def self.twice; yield; yield; end
+    #   theory[:twice][0] = method :twice
+    #
+    # Secondly, as a callable term. A callable term is a term that responds to
+    # #prove, and yields if and the number of times the represented predicate is
+    # provable. This implementation calls the proc/method with the variables from
+    # the sentence passed as arguments, and yields once iff the proc/method
+    # returned true. This permits the use of block instead of a callable term.
+    # Examples:
+    #   :good_age(A).if {|a|a >= 13}
+    #
+    #   :greet(N).if female(N).and {|n| puts "Hello, Ms. #{n}"; true }
+    #   :greet(N).if   male(N).and {|n| puts "Hello, Mr. #{n}"; true }
+    #
+    # Thirdly, as a function. A function is a term that responds to
+    # #rubylog_resolve_function and does something else than returning self.
+    # Built-in predicates with two or more arguments, that require a not
+    # necessarily callable term as their last argument should call
+    # rubylog_resolve_function on this argument if it responds to it. This
+    # permits users to use a block instead of the last argument. Examples:
+    #   :greeting(N,G).if female(N).then G.is {|n| "Hello, Ms. #{n}" }
+    #   :greeting(N,G).if   male(N).then G.is {|n| "Hello, Mr. #{n}" }
+    #
+
+
+    def self.included class_or_module
+      class_or_module.send :include, Rubylog::Callable
+
+      # procs and methods are composite terms, just to simply get
+      # access to variables
+      class_or_module.send :include, Rubylog::CompositeTerm
+    end
+
+    # Callable methods
+    def prove
+      yield if call_with_rubylog_variables
+    end
+
+
+    def call_with_rubylog_variables
+      raise Rubylog::InvalidStateError, "variables not available" if not @rubylog_variables
+      if arity == -1
+        call *@rubylog_variables.map{|v|v.value}
+      else
+        call *@rubylog_variables[0...arity].map{|v|v.value}
+      end
+    end
+
+    # Term methods
+    def rubylog_resolve_function
+      call_with_rubylog_variables
+    end
+
+    # CompositeTerm methods
+    def rubylog_clone 
+      yield dup
+    end
+  end
+end
+

data/lib/rubylog/term.rb

@@ -0,0 +1,20 @@
+module Rubylog
+  module Term
+    def rubylog_clone
+      yield self
+    end
+
+    def rubylog_variables
+      []
+    end
+
+    def rubylog_resolve_function
+      self
+    end
+
+
+  end
+
+
+
+end

data/lib/rubylog/theory.rb

@@ -0,0 +1,133 @@
+module Rubylog
+  class Cut < StandardError
+  end
+
+  def self.theory
+    Thread.current[:rubylog_theory]
+  end
+
+  class Theory
+    include Rubylog::DSL::Constants
+
+    def self.new!
+      Thread.current[:rubylog_theory] = new
+    end
+
+    def initialize
+      @database = Hash.new{|h,k| h[k] = 
+        {}
+      }.merge! BUILTINS
+      @variable_bindings = []
+      @public_interface = Module.new
+      @trace = false
+    end
+
+    def [] *args
+      database[*args]
+    end
+
+    def clear
+      initialize
+    end
+
+
+    # directives
+    #
+    def predicate *descs
+      descs.each do |desc|
+        create_predicate *desc
+      end
+    end
+
+    def discontinuous *descs
+      descs.each do |desc|
+        create_predicate(*desc).discontinuous!
+      end
+    end
+
+    attr_reader :database
+    attr_reader :public_interface
+
+
+    # predicates
+
+    def assert head, body=:true
+      functor, arity = head.functor, head.arity
+      predicate = database[functor][arity]
+      if predicate
+        check_assertable predicate, head, body
+      else
+        predicate = create_predicate functor, arity
+      end
+      predicate << Clause.new(:-, head, body)
+      @last_predicate = predicate
+    end
+
+
+    def solve goal
+      goal = goal.rubylog_compile_variables 
+      goal.prove { yield(*goal.rubylog_variables.map{|v|v.value}) }
+    end
+
+    def true? goal
+      goal = goal.rubylog_compile_variables
+      goal.prove { return true }
+      false
+    end
+
+    # debugging
+    #
+    #
+    def trace?
+      @trace
+    end
+
+    def trace!
+      @trace=true
+      @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?
+    end
+
+    protected
+
+
+    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?
+    end
+      
+    def create_predicate functor, arity
+      DSL.add_functors_to @public_interface, functor
+      database[functor][arity] = Predicate.new
+    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
+    #end
+
+
+  end
+end
+
+
+
+
+
+

data/lib/rubylog/unifiable.rb

@@ -0,0 +1,19 @@
+module Rubylog
+  module Unifiable
+    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
+  end
+end

data/lib/rubylog/variable.rb

@@ -0,0 +1,97 @@
+module Rubylog
+  class Variable
+
+    # data structure
+
+    attr_reader :name
+    def initialize name
+      @name = name
+      @assigned = false
+      @dont_care = !!(name.to_s =~ /^(?:ANY|_)/)
+    end
+
+    def assigned?
+      @assigned
+    end
+
+    def inspect
+      @name.to_s
+    end
+
+    def to_s
+      @name.to_s
+    end
+
+    def == other
+      Variable === other and @name == other.name
+    end
+
+    def eql? other
+      Variable === other and @name == other.name
+    end
+
+
+
+    def value
+      return nil if (val = rubylog_dereference).kind_of? Variable
+      val
+    end
+
+    def dont_care? 
+      @dont_care
+    end
+
+    # Term methods
+
+    # rubylog_clone stays as is
+    
+    def rubylog_variables
+      [self]
+    end
+
+    # Unifiable methods
+    include Unifiable
+
+    def rubylog_unify other
+      if @assigned
+        rubylog_dereference.rubylog_unify(other) do yield end
+      else
+        begin
+          @assigned = true; @value = other
+          yield
+        ensure
+          @assigned = false
+        end
+      end
+    end
+
+    def rubylog_dereference
+      if @assigned
+        @value.rubylog_dereference
+      else
+        self
+      end
+    end
+
+    def rubylog_deep_dereference
+      if @assigned
+        @value.rubylog_deep_dereference
+      else
+        self
+      end
+    end
+
+    # Callable methods
+    include Callable
+
+    def prove
+      # XXX not tested
+      v = value
+      raise InstantiationError if v.nil?
+      v.prove{yield}
+    end
+
+  end
+
+
+end

data/lib/rubylog.rb

@@ -0,0 +1,39 @@
+# rubylog.rb -- Prolog workalike for Ruby
+# github.com/cie/rubylog
+
+# rtl
+require 'set'
+
+# interfaces
+require 'rubylog/term.rb'
+require 'rubylog/callable.rb'
+require 'rubylog/unifiable.rb'
+require 'rubylog/composite_term.rb'
+
+# helpers
+require 'rubylog/dsl.rb'
+require 'rubylog/dsl/constants.rb'
+require 'rubylog/dsl/first_order_functors.rb'
+require 'rubylog/dsl/global_functors.rb'
+require 'rubylog/dsl/second_order_functors.rb'
+require 'rubylog/proc_method_additions.rb'
+require 'rubylog/internal_helpers.rb'
+
+# classes
+require 'rubylog/errors.rb'
+require 'rubylog/predicate.rb'
+require 'rubylog/theory.rb'
+require 'rubylog/variable.rb'
+
+# builtins
+require 'rubylog/builtins.rb'
+
+require 'rubylog/clause.rb'
+require 'array.rb'
+require 'symbol.rb'
+require 'proc.rb'
+require 'object.rb'
+require 'class.rb'
+require 'method.rb'
+
+Rubylog::Theory.new!