rubylog 0.0.1 → 1.0.0

data/lib/rubylog/builtins.rb

@@ -1,193 +0,0 @@
-module Rubylog
-  BUILTINS = Hash.new{|h,k| h[k] = {}}
-
-  class << Object.new
-    def singleton_method_added name
-      unless name == :singleton_method_added
-        m = method(name)
-        BUILTINS[name][m.arity] = m
-      end
-    end
-
-
-    # prolog builtins
-
-    def true
-      yield
-    end
-
-    def fail
-    end
-
-    def and a, b
-      a.prove { b.prove { yield } }
-    end
-
-    def cut
-      yield
-      raise Cut
-    end
-
-    def or a, b
-      a.prove { yield }
-      b.prove { yield }
-    end
-
-    def then a,b
-      stands = false
-      a.prove { stands = true ; break }
-      b.prove { yield } if stands
-    end
-
-    def is_false a
-      a.prove { return }
-      yield
-    end
-
-    def repeat # XXX not tested
-      yield while true
-    end
-
-    # unification
-
-    def is a,b
-      a = a.rubylog_resolve_function
-      b = b.rubylog_resolve_function
-      a.rubylog_unify(b) { yield }
-    end
-
-    
-
-    def matches a,b
-      a = a.rubylog_resolve_function
-      b = b.rubylog_resolve_function
-      yield if b.rubylog_dereference === a.rubylog_dereference
-    end
-
-    def splits_to a,h,t
-      t = t.rubylog_dereference
-      if t.instance_of? Rubylog::Variable
-        a = a.rubylog_dereference
-        if a.instance_of? Rubylog::Variable
-          InternalHelpers.non_empty_list {|l|
-            t.rubylog_unify(l.drop 1) {
-              h.rubylog_unify(l[0]) {
-                a.rubylog_unify(l) {
-                  yield
-                }
-              }
-            }
-          }
-        elsif a.instance_of? Array 
-          if a.size > 0
-            h.rubylog_unify(a.first) { t.rubylog_unify(a.drop 1) { yield } }
-          end
-        end
-      elsif t.instance_of? Array
-        a.rubylog_unify([h]+t) { yield }
-      end
-    end
-
-    def in a,b
-      a = a.rubylog_resolve_function
-      b = b.rubylog_resolve_function.rubylog_dereference
-      if b.instance_of? Rubylog::Variable # XXX not tested
-        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 _p a
-      p a.rubylog_deep_dereference
-      yield
-    end
-
-    def _puts a
-      puts a.rubylog_deep_dereference
-      yield
-    end
-
-    def _print a
-      print a.rubylog_deep_dereference
-      yield
-    end
-
-    def nl
-      puts
-      yield
-    end
-
-    def all a,b
-      a.prove {
-        stands = false; 
-        b.prove { stands = true; break } 
-        return if not stands
-      }
-      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 all a
-      a.prove { }
-      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
-
-
-  end
-
-
-  # aliases
-  BUILTINS[:&][2] = BUILTINS[:and][2]
-  BUILTINS[:|][2] = BUILTINS[:or][2]
-  BUILTINS[:~][1] = 
-    BUILTINS[:not][1] =
-    BUILTINS[:none][1] =
-    BUILTINS[:fails][1] = BUILTINS[:is_false][1]
-  BUILTINS[:false][0] = BUILTINS[:fail][0]
-
-  DSL.add_first_order_functor :is, :matches, :in, :_p, :_puts, :_print
-  DSL.add_second_order_functor :and, :or, :then, :is_false, :&, :|, :~, :not, :all, :any, :one, :none, :fails
-  DSL.add_functors_to Array, :splits_to
-
-end

data/lib/rubylog/callable.rb

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

data/lib/rubylog/composite_term.rb

@@ -1,38 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

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

data/lib/rubylog/dsl/global_functors.rb

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

data/lib/rubylog/dsl/second_order_functors.rb

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

data/lib/rubylog/internal_helpers.rb

@@ -1,16 +0,0 @@
-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

@@ -1,34 +0,0 @@
-
-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

@@ -1,69 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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/unifiable.rb

@@ -1,19 +0,0 @@
-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/symbol.rb

@@ -1,35 +0,0 @@
-class Symbol
-
-  # a proxy for Clause
-  def functor
-    self
-  end
-
-  def arity
-    0
-  end
-
-  def desc
-    [self, 0]
-  end
-
-  def args
-    []
-  end
-
-  # Unifiable methods
-  include Rubylog::Unifiable
-
-  # Callable methods
-  include Rubylog::Callable
-
-  def prove
-    predicate = Rubylog.theory[self][0]
-    raise Rubylog::ExistenceError, desc.inspect if not predicate
-    predicate.call(*args) { yield }
-  end
-
-  # Second-order functors (:is_false, :and, :or, :then)
-  include Rubylog::DSL::SecondOrderFunctors
-
-end

data/script/inriasuite2spec.pl

@@ -1,22 +0,0 @@
-%:-
-%
-:- op( 20, xfx, <-- ).
-
-main :- 
-  open_file,
-  repeat,
-  (read([Goal, Result]); halt), 
-  print_assertion(Goal, Result),
-  fail; true.
-
-
-open_file :-
-  argument_list([Filename]),
-  open(Filename, read, S),
-  set_input(S).
-
-
-print_assertion(Goal, Result) :-
-  write(Goal), write(Result), nl.
-
-:- initialization(main).

data/spec/rubylog/clause_spec.rb

@@ -1,81 +0,0 @@
-require 'rubylog'
-
-class << Rubylog.theory
-  describe "clauses" do
-    it "can be created" do
-      (:john.is_happy).should be_kind_of Rubylog::Term
-      (:john.likes :beer).should be_kind_of Rubylog::Term
-      (A.likes :beer).should be_kind_of Rubylog::Term
-      (:john.likes Drink).should be_kind_of Rubylog::Term
-      (:john.likes :drinking.in :bar).should be_kind_of Rubylog::Term
-    end
-    it "forbids non-declared names" do
-      lambda { :john.something_else }.should raise_error(NoMethodError)
-    end
-    it "also work with operators" do
-      (:is_happy%1).should be_kind_of Rubylog::Term
-      (A%B).should be_kind_of Rubylog::Term
-    end
-    it "can be asked for their functor" do
-      (:john.is_happy).functor.should == :is_happy
-      (:is_happy%1).functor.should == :%
-      (A%1).functor.should == :%
-      (:john.likes :drinking.in :bar).functor.should == :likes
-    end
-    it "can be indexed" do
-      (:john.is_happy)[0].should == :john
-      (:john.likes :beer)[0].should == :john
-      (:john.likes :beer)[1].should == :beer
-      (:john.likes(:cold, :beer))[2].should == :beer
-      (:john.likes(:cold, :beer))[1..2].should == [:cold,:beer]
-      (:john.likes :drinking.in :bar)[1].should == (:drinking.in :bar)
-    end
-    it "can be asked for their args" do
-      (:john.is_happy).args.should == [:john]
-      (:john.likes :beer).args.should == [:john, :beer]
-      (:john.likes(:cold, :beer)).args.should == [:john, :cold, :beer]
-      (:john.likes :drinking.in :bar).args.should == [:john, :drinking.in(:bar)]
-    end
-    it "support ==" do
-      (:john.is_happy).should == (:john.is_happy)
-      (:john.is_happy).should_not be_equal(:john.is_happy)
-      (:john.is_happy).should_not == nil
-      (:john.is_happy).should_not == 9
-      (:john.is_happy).should_not == :john
-      (:john.is_happy).should_not == Rubylog
-      (:john.likes :drinking.in :bar).should == (:john.likes :drinking.in :bar)
-    end
-    it "support eql?" do
-      (:john.is_happy).should be_eql(:john.is_happy)
-      (:john.is_happy).should_not be_eql nil
-      (:john.is_happy).should_not be_eql 9
-      (:john.is_happy).should_not be_eql :john
-      (:john.is_happy).should_not be_eql Rubylog
-      (:john.likes :drinking.in :bar).should be_eql(:john.likes :drinking.in :bar)
-    end
-    it "support hash" do
-      (:john.is_happy).hash.should == (:john.is_happy).hash
-      (:john.likes :drinking.in :bar).hash.should == 
-        (:john.likes :drinking.in :bar).hash
-    end
-    it "support inspect" do
-      (:john.is_happy).inspect.should == ":john.is_happy"
-      (:john.likes :beer).inspect.should == ":john.likes(:beer)"
-      (:john.likes :drinking,:beer).inspect.should == ":john.likes(:drinking, :beer)"
-      (:john.likes :drinking.in :bar).inspect.should == ":john.likes(:drinking.in(:bar))"
-    end
-    it "can tell their arity" do
-      (:john.is_happy).arity.should == 1
-      (:john.likes :beer).arity.should == 2
-      (:john.likes :drinking,:beer).arity.should == 3
-      (:john.likes :drinking.in :bar).arity.should == 2
-    end
-    it "can tell their descriptor" do
-      (:john.is_happy).desc.should == [:is_happy,1]
-      (:john.likes :beer).desc.should == [:likes,2]
-      (:john.likes :drinking,:beer).desc.should == [:likes,3]
-      (:john.likes :drinking.in :bar).desc.should == [:likes,2]
-    end
-  end
-
-end

data/spec/rubylog/variable_spec.rb

@@ -1,25 +0,0 @@
-require 'rubylog'
-
-class << Rubylog.theory
-  describe "variables" do
-    it "are undefined constants" do 
-      [A, SomethingLong].each{|x|x.should be_kind_of Rubylog::Variable}
-    end
-
-    it "support ==" do 
-      A.should == A
-    end
-
-    it "support eql?" do
-      A.should be_eql A
-    end
-
-    it "returns different instances" do
-      A.should_not be_equal A
-    end
-
-    specify "that start with ANY... are dont care" do 
-      [ANY, ANYTHING, ANYTIME].each{|x|x.should be_kind_of Rubylog::Variable; x.should be_dont_care}
-    end
-  end
-end