rubylog 2.0.0 → 2.0.1

data/Gemfile

@@ -1,6 +1,7 @@
 source "http://rubygems.org"
 
 group :development do
+  gem "ruby-prof"
   gem "rspec", ">= 2.8.0", " < 3"
   gem "yard", "~> 0.7"
   gem "bundler", ">= 1.0.0"

data/Gemfile.lock

@@ -21,6 +21,7 @@ GEM
     rspec-expectations (2.13.0)
       diff-lcs (>= 1.1.3, < 2.0)
     rspec-mocks (2.13.1)
+    ruby-prof (0.13.0)
     simplecov (0.7.1)
       multi_json (~> 1.0)
       simplecov-html (~> 0.7.1)
@@ -34,5 +35,6 @@ DEPENDENCIES
   bundler (>= 1.0.0)
   jeweler (>= 1.8.3)
   rspec (>= 2.8.0, < 3)
+  ruby-prof
   simplecov
   yard (~> 0.7)

data/README.rdoc

@@ -33,7 +33,6 @@ Another option is to use Kernel#rubylog:
 
 
   require 'rubylog'
-  extend Rubylog::Context
 
   rubylog do
     # your code here
@@ -84,7 +83,7 @@ Declaring a predicate with arguments gives you three methods on the subject clas
 
   predicate_for String, ".likes()"
   'John'.likes('beer')    # returns a structure object representing this logical statement
-  'John'.likes!('beer')   # asserts that this statement as a fact
+  'John'.likes!('beer')   # asserts this statement as a fact
   'John'.likes?('beer')   # tells if this statement is true (in this case, returns true)
 
 === Nullary predicates
@@ -271,7 +270,7 @@ These predicates also have a prefix form, which can be used to create more natur
   check none X.in([1,3]), X.even
   check iff X.in([2,4]), X.in(1..4).and(X.even)
 
-There is another quantifier, which only has a prefix form <tt>every(A, B)</tt>. This works similarly to <tt>.all()</tt>, but for each solution of A, creates a copy of B and chains them together with <tt>.and()</tt>. It can be useful for work with assumptions, see below. This is an experimental feature, and still contains bugs.
+There is another quantifier <tt>A.every(B)</tt> or <tt>every(A,B)</tt>. This works similarly to <tt>.all()</tt>, but for each solution of A, creates a copy of B and chains them together with <tt>.and()</tt>. It can be useful for work with assumptions, see below. This is an experimental feature, and still contains bugs.
 
 === File system
 
@@ -335,6 +334,10 @@ You can turn on tracing with
 
   Rubylog.trace
 
+And turn off with
+
+  Rubylog.trace false
+
 Or, you can trace a specific code block with
 
   Rubylog.trace do

data/RELEASE_NOTES.rdoc

@@ -4,7 +4,11 @@
   * warning for singleton variables
   * predicate for checking bound/unbound variables
 
-== Version 2.0.0 (to be released)
+== Version 2.0.1
+* Bug fixes
+  * <tt>"a/b".file\_in("a")</tt> only succeeds once
+
+== Version 2.0.0
 * Backwards incompatibilities
   * <tt>Rubylog.theory</tt> renamed to <tt>Kernel#rubylog</tt>.
   * <tt>file\_in</tt> includes directories and yields relative paths.

data/Rakefile

@@ -51,4 +51,4 @@ task :yardserver do
 end
 
 
-
+task :default => :spec

data/VERSION

@@ -1 +1 @@
-2.0.0
+2.0.1

data/examples/benchmark/compiled_not_indexed.rb

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+require "rubylog"
+extend Rubylog::Context
+
+
+class << primitives
+  def self.make_tree(parent, levels, s="")
+    return if levels.zero?
+
+    children = (1..DEGREES).map{random_person} 
+
+    s << "a.rubylog_unify(#{parent.inspect}){\n" 
+    children.each do |child|
+      s << "b.rubylog_unify(#{child.inspect}){yield}\n"
+    end 
+    s << "}\n"
+    children.each do |child|
+      make_tree(child, levels-1, s)
+    end
+    s
+  end 
+
+  eval "def parent_of a,b
+    #{make_tree(random_person, LEVELS)}
+  end"
+
+  def grandparent_of a,b
+    x = Rubylog::Variable.new
+    parent_of(a,x) { parent_of(x,b) { yield }}
+  end 
+end 
+

data/examples/benchmark/compiled_sequence_indexed.rb

@@ -0,0 +1,47 @@
+# encoding: UTF-8
+require "rubylog"
+extend Rubylog::Context
+
+
+class << primitives
+  def self.make_tree(parent, levels, all="", indexed= "")
+    return if levels.zero?
+
+    children = (1..DEGREES).map{random_person} 
+
+    all << "a.rubylog_unify(#{parent.inspect}){\n" 
+    children.each do |child|
+      all << "b.rubylog_unify(#{child.inspect}){yield}\n"
+    end 
+    all << "}\n"
+
+    indexed << "when #{parent.inspect}\n" 
+    children.each do |child|
+      indexed << "b.rubylog_unify(#{child.inspect}){yield}\n"
+    end 
+
+    children.each do |child|
+      make_tree(child, levels-1, all, indexed)
+    end
+    
+  end 
+
+  all =""; indexed =""
+  make_tree(random_person, LEVELS, all, indexed)
+
+  eval "def parent_of a,b
+    a = a.rubylog_dereference
+    case a
+    when Rubylog::Variable
+      #{all}
+    #{indexed}
+    end 
+  end"
+
+  def grandparent_of a,b
+    x = Rubylog::Variable.new
+    parent_of(a,x) { parent_of(x,b) { yield }}
+  end 
+end 
+
+

data/examples/benchmark/indexed_procedure.rb

@@ -0,0 +1,57 @@
+class Rubylog::Procedure
+  def initialize functor, arity, rules=Array.new
+    super functor, arity
+    @rules = rules
+    @index = {}
+  end
+
+  def each(args)
+    index = args[0].rubylog_dereference
+    if !index.is_a? Rubylog::Variable
+      (@index[index] || []).each do |rule|
+        yield rule
+      end 
+    else
+      @rules.each do |rule|
+        yield rule
+      end 
+    end
+  end 
+  rubylog_traceable :each
+
+  # accepts the *args of the called structure
+  def call *args
+    # catch cuts
+    catch :rubylog_cut do
+
+      # for each rule
+      each(args) do |rule|
+        # compile
+        rule = rule.rubylog_match_variables
+
+        # unify the head with the arguments
+        rule.head.args.rubylog_unify(args) do
+          # call the body
+          rule.body.prove do
+            yield 
+          end
+        end
+      end
+    end
+  end
+  rubylog_traceable :call
+
+  # Asserts a rule with a given head and body, indexed
+  def assert head, body = :true
+    rule = Rubylog::Rule.new(head, body)
+
+    # update index
+    index = head[0].rubylog_dereference 
+    if !index.is_a? Rubylog::Variable
+      (@index[index] ||= []).push rule
+    end
+
+    @rules.push rule
+  end 
+end 
+

data/examples/benchmark/prolog.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+#
+
+puts "Native prolog"
+
+def make_prolog_tree(parent, levels, s="")
+  return if levels.zero?
+
+  children = (1..DEGREES).map{random_person} 
+
+  children.each do |child|
+    s << "parent_of(#{parent},#{child}).\n"
+  end 
+  children.each do |child|
+    make_prolog_tree(child, levels-1, s)
+  end
+  s
+end 
+
+s = make_prolog_tree(random_person, LEVELS)
+s << <<EOT
+grandparent_of(A,B) :- parent_of(A,X), parent_of(X,B).
+
+:- dynamic(result/1).
+
+main :- findall([A,B],grandparent_of(A,B),L), assertz(result(L)), halt.
+
+:- initialization(main).
+EOT
+
+File.open(File.expand_path(__FILE__+"/../prolog.pl"), "w") do |f|
+  f << s
+end 
+
+system 'gplc ./examples/benchmark/prolog.pl'
+system 'bash -c "time ./examples/benchmark/prolog"'
+
+
+

data/examples/benchmark/pure.rb

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+require "rubylog"
+extend Rubylog::Context
+
+predicate_for $person_class, ".parent_of() .grandparent_of()"
+
+def make_tree(parent, levels)
+  return if levels.zero?
+
+  children = (1..DEGREES).map{random_person} 
+
+  children.each do |child|
+    # add relationship
+    parent.parent_of!(child)
+  end
+
+  children.each do |child|
+    # make sub-tree
+    make_tree(child, levels-1)
+  end 
+end 
+
+make_tree(random_person, LEVELS)
+
+A.grandparent_of(B).if A.parent_of(X).and X.parent_of(B)
+

data/examples/benchmark.rb

@@ -0,0 +1,113 @@
+# benchmark
+#
+# The task is to collect all grandparent-granchild relationships in a family
+# tree to an array.
+# First it is done with pure rubylog. Second, it is done with compiled rubylog
+#
+#
+
+require "rubylog"
+require "benchmark"
+require "ruby-prof"
+
+
+DEGREES = 3
+LEVELS = 6
+NAME_LENGTH = 5
+
+class Person
+  def initialize name
+    @name = name
+  end 
+
+  def inspect
+    # this is a quick solution for compiled*.rb code to retrieve the object
+    "ObjectSpace._id2ref(#{object_id})"
+  end 
+
+  def to_s
+    # this is needed for comparing results
+    @name
+  end 
+end 
+
+# create a random person
+def random_person
+  # create random name
+  name = ""
+  NAME_LENGTH.times { name << (97+$random.rand(26)).chr}
+  name
+
+  if $person_class == String
+    name
+  elsif $person_class == Symbol
+    name.to_sym
+  elsif $person_class = Person
+    Person.new(name)
+  end
+end 
+
+def run_benchmark(id, person_class, name)
+  $person_class = person_class
+  $random = Random.new(1)
+
+  load "./examples/benchmark/#{id}.rb"
+
+  puts name
+
+  result = nil
+  time = Benchmark.realtime {
+    result = rubylog do
+      A.grandparent_of(B).map do
+        [A.to_s,B.to_s]
+      end
+    end
+  }
+  puts "%0.5f sec" % time
+
+
+  # forget result
+  result = result.inspect
+
+  # compare with last result
+  raise "#{$last_result} != #{result}" if $last_result && $last_result != result
+  $last_result = result
+
+  # make garbage collection
+  GC.start; sleep(time*1.2+1)
+end 
+
+puts "Rubylog Grandparent Benchmark"
+puts
+puts "DEGREES = #{DEGREES}"
+puts "LEVELS = #{LEVELS}"
+puts "NAME_LENGTH = #{NAME_LENGTH}"
+puts "NODES = #{DEGREES**LEVELS}"
+puts
+
+
+
+run_benchmark "pure", String, "Strings"
+run_benchmark "pure", Person, "Objects"
+run_benchmark "pure", Symbol, "Symbols"
+puts
+
+require "./examples/benchmark/indexed_procedure"
+
+run_benchmark "pure", String, "Strings indexed"
+run_benchmark "pure", Person, "Objects indexed"
+run_benchmark "pure", Symbol, "Symbols indexed"
+puts
+
+run_benchmark "compiled_not_indexed", String, "Strings compiled"
+run_benchmark "compiled_not_indexed", Person, "Objects compiled"
+run_benchmark "compiled_not_indexed", Symbol, "Symbols compiled"
+puts
+
+run_benchmark "compiled_sequence_indexed", String, "Strings compiled, sequentially indexed"
+#run_benchmark "compiled_sequence_indexed", Person, "Objects compiled, sequentially indexed"
+run_benchmark "compiled_sequence_indexed", Symbol, "Symbols compiled, sequentially indexed"
+puts
+
+# native prolog
+load "./examples/benchmark/prolog.rb"

data/examples/divisors.rb

@@ -1,6 +1,4 @@
 $:.unshift File.dirname(__FILE__)+"/../lib"
 require "rubylog"
 
-extend Rubylog::Context
-
-p (P.is(672).and A.in{1..P}.and P.product_of(A,B).and{A<=B}).count
+p rubylog { P.is(672).and A.in{1..P}.and P.product_of(A,B).and{A<=B} }.count

data/examples/factorial.rb

@@ -6,11 +6,12 @@ rubylog do
 
   0.factorial! 1
   N[thats > 0].factorial(K).if \
-    N1.is{N-1}.
+    N.sum_of(N1,1).
     and N1.factorial(K1).
-    and K.is{N*K1}
+    and K.product_of(K1,N)
 
   7.factorial(N).solve {puts N}
 end
 
 
+

data/examples/file_search.rb

@@ -1,14 +1,16 @@
 require "rubylog"
 extend Rubylog::Context
 
-predicate_for String, "FILE.found_in(DIR)"
+[true,false].each do |b|
+  puts "Files which #{b ? 'have' : 'do not have'} spec:"
 
-FILE.found_in(DIR).if FILE.file_in(DIR)
-FILE.found_in(DIR).if DIR2[thats_not =~ /\/\./].dir_in(DIR).and FILE.found_in(DIR2)
+  "lib/#{X}.rb".file_in("lib/**").each do
+    if b == "spec/#{X}_spec.rb".file_in?("spec/**")
+      puts X
+    end
+  end
 
-"lib/#{X}.rb".found_in("lib").and "lib/#{X}"
-"#{X}/spec/#{S}_spec.rb".found_in("spec").each do
-  puts S
-end
+  puts
 
+end
 

data/examples/hanoi.rb

@@ -1,23 +1,22 @@
 $:.unshift File.dirname(__FILE__)+"/../lib"
 require "rubylog"
+extend Rubylog::Context
 
-rubylog do
-  predicate_for Integer, ".move(,,)", ".hanoi"
+predicate_for Integer, ".move(,,)", ".hanoi"
 
-  0.move(ANY,ANY,ANY).if :cut!
-  N.move(A,B,C).if (
-    M.is{N-1}.and \
-    M.move(A,C,B).and \
-    { puts "move disc #{N} from the #{A} pole to the #{B} pole" or true }.and \
-    M.move(C,B,A)
-  )
-  N.hanoi.if N.move('left', 'right', 'center')
+0.move(ANY,ANY,ANY).if :cut!
+N.move(A,B,C).if (
+  M.is{N-1}.and \
+  M.move(A,C,B).and \
+  { puts "move disc #{N} from the #{A} pole to the #{B} pole" or true }.and \
+  M.move(C,B,A)
+)
+N.hanoi.if N.move('left', 'right', 'center')
 
-  puts "\nWhat's the solution for a single disc?"
-  solve 1.hanoi
+puts "\nWhat's the solution for a single disc?"
+solve 1.hanoi
 
-  puts "\n\nWhat's the solution for 5 discs?"
-  solve 5.hanoi
+puts "\n\nWhat's the solution for 5 discs?"
+solve 5.hanoi
 
 
-end

data/examples/hu/csaladfa.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+require "rubylog"
+extend Rubylog::Context
+
+predicate_for String, ".parent_of() .grandparent_of()"
+
+# ki kinek a szülője
+'Bob'.parent_of!('Greg')
+'Greg'.parent_of!('John')
+'Greg'.parent_of!('Jane')
+
+# "A" nagyszülője B-nek, ha "A" szülője X-nek és X szülője B-nek
+A.grandparent_of(B).if A.parent_of(X).and X.parent_of(B)
+
+# Az összes nagyszülő-unoka kapcsolat kiírása
+A.grandparent_of(B).each do
+  puts "#{A} unokája #{B}."
+end 

data/examples/mice2.rb

@@ -1,19 +1,37 @@
 require "rubylog"
 extend Rubylog::Context
 
-predicate_for Array, ".array(N) Peek.matches(Guess)"
+predicate_for Rubylog::Variable, ".bound"
+A.bound.if { A.is_a? Rubylog::Variable }
 
-[].peek!(0)
-[K,*REST].mice(N[thats>0]).if K.in([0,1]).and N.sum_of(N1,1).and REST.mice(N1)
+class Array
+  extend Rubylog::Context
 
-[].seen!([])
-[0,*REST].seen([nil,*REST2]).if REST.seen(REST2)
-[1,*REST].seen([A,*REST2]).if A.in([0,1]).and REST.seen(REST2)
+  predicate ".can_have_neighbours"
+  [*ANY,:yes,:yes,*ANY].can_have_neighbours!
+
+  predicate ".has_neighbours"
+  [*ANY,A,B,*ANY].has_neighbours.if { A == :yes && B == :yes}
+
+  predicate ".cannot_have_neighbours"
+  A.cannot_have_neighbours.if A.can_have_neighbours.false
+
+  predicate ".decidable"
+  A.decidable.if A.has_neighbours.or A.cannot_have_neighbours
+
+
+  predicate ".guessed"
+  A.guessed.if every X.in(A), X.is(:yes).or(X.is(:no)).or(:true)
+
+  predicate ".easy"
+  A.easy.if A.guessed.and A.decidable.and any X.in(A), X.bound.false
+
+  Rubylog.trace
+  N.in(0..6).each do
+    puts "#{N}: #{([ANY]*N).easy?}"
+  end 
+
+end 
 
-[].guess!([])
-[nil,*REST].guess([A,*REST2]).if A.in([0,1]).and REST.guess(REST2)
-[0,*REST].guess([0,*REST2]).if A.in([0,1]).and REST.guess(REST2)
-[1,*REST].guess([1,*REST2]).if A.in([0,1]).and REST.guess(REST2)
 
-solve N.is(6).and any Peek.peek(N), all(Peek.seen(Seen), all(Guess.guess(Seen), Guess.has_neighbors.false).or(all(Guess.guess(Seen), Guess.has_neighbors)))
 

data/examples/sudoku.rb

@@ -1,52 +1,17 @@
 $:.unshift File.dirname(__FILE__)+"/../lib"
 require "rubylog"
 
-class Sudoku
-  def initialize
-    @rows = (1..9).map{(1..9).map{Rubylog::Variable.new}}
-  end
-
-  attr_reader :rows
-  
-  def columns
-    @rows.transpose
-  end
-
-  def blocks
-    (0..2).map {|a| (0..2).map {|b| (0..2).map {|c| (0..2).map {|d| 
-      @rows[a*3+c][b*3+d]
-    }}.flatten(1) }}.flatten(1)
-  end
-
-  extend Rubylog::Context
-
-  predicate_for Array, ".unique"
-  L.unique.unless L.is [*ANY, X, *ANY, X, *ANY]
-
-  predicate ".solved .good .shown .given(s)"
-  S.solved.if every L.in{S.rows}.and(F.in(L)), F.in(1..9)
-  S.good.if all(T.in{[S.rows, S.columns, S.blocks]}.and(L.in{T}), L.unique)
+def blocks_of s
+  (0..2).map {|a| (0..2).map {|b| (0..2).map {|c| (0..2).map {|d| 
+    s[a*3+c][b*3+d]
+  }}.flatten(1) }}.flatten(1)
+end
 
-  S.shown.if do
-    L.in{S.rows}.each do
-      p L
-    end
-    puts 
-    true
-  end
+predicate_for Array, ".sudoku .row_unique .col_unique .block_unique .unique"
 
-  _=ANY
-  solve S.is{Sudoku.new}.and lambda{S.rows}.is([
-                                     [5,_,_,_,2,4,7,_,_],
-                                     [_,_,2,_,_,_,8,_,_],
-                                     [1,_,_,7,_,3,9,_,2],
-                                     [_,_,8,_,7,2,_,4,9],
-                                     [_,2,_,9,8,_,_,7,_],
-                                     [7,9,_,_,_,_,_,8,_],
-                                     [_,_,_,_,3,_,5,_,6],
-                                     [9,6,_,_,1,_,3,_,_],
-                                     [_,5,_,6,9,_,_,1,_]
-  ]).and S.solved.and S.good.and S.shown rescue p $!
-end
+S.sudoku.if S.is([[ANY]*9]*9).and S.row_unique.and S.col_unique.and S.block_unique.and every(ROW.in(S).and(X.in(ROW)), X.in(1..9))
 
+S.row_unique.if every ROW.in(S), ROW.unique
+S.col_unique.if every COL.in{S.transpose}, COL.unique
+S.col_unique.if every BLOCK.in{blocks_of(S)}, BLOCK.unique
 

data/lib/rubylog/builtins/file_system.rb

@@ -14,7 +14,7 @@ rubylog do
       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) }
+  X.file_in(D).if proc{! X.is_a? Rubylog::Variable and D.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.

data/rubylog.gemspec

@@ -5,17 +5,16 @@
 
 Gem::Specification.new do |s|
   s.name = "rubylog"
-  s.version = "2.0.0"
+  s.version = "2.0.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Bern\u{e1}t Kall\u{f3}"]
-  s.date = "2013-05-07"
+  s.date = "2013-05-16"
   s.description = "Rubylog is a Prolog-like DSL for Ruby."
   s.email = "kallo.bernat@gmail.com"
   s.extra_rdoc_files = [
     "LICENSE.txt",
-    "README.rdoc",
-    "README.rdoc.orig"
+    "README.rdoc"
   ]
   s.files = [
     ".document",
@@ -29,6 +28,12 @@ Gem::Specification.new do |s|
     "TODO.txt",
     "VERSION",
     "examples/a_plus_b.rb",
+    "examples/benchmark.rb",
+    "examples/benchmark/compiled_not_indexed.rb",
+    "examples/benchmark/compiled_sequence_indexed.rb",
+    "examples/benchmark/indexed_procedure.rb",
+    "examples/benchmark/prolog.rb",
+    "examples/benchmark/pure.rb",
     "examples/checkmate.rb",
     "examples/combination.rb",
     "examples/dcg.rb",
@@ -41,6 +46,7 @@ Gem::Specification.new do |s|
     "examples/file_search.rb",
     "examples/hanoi.rb",
     "examples/hello.rb",
+    "examples/hu/csaladfa.rb",
     "examples/mice.rb",
     "examples/mice2.rb",
     "examples/n_queens.rb",
@@ -170,7 +176,6 @@ Gem::Specification.new do |s|
     "spec/inriasuite_spec.rb",
     "spec/integration/custom_classes_spec.rb",
     "spec/integration/dsl_spec.rb",
-    "spec/integration/recursion_spec.rb",
     "spec/integration/theory_as_module_spec.rb",
     "spec/integration/theory_as_module_with_include_spec.rb",
     "spec/rspec/rubylog_spec.rb",
@@ -215,12 +220,14 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<ruby-prof>, [">= 0"])
       s.add_development_dependency(%q<rspec>, ["< 3", ">= 2.8.0"])
       s.add_development_dependency(%q<yard>, ["~> 0.7"])
       s.add_development_dependency(%q<bundler>, [">= 1.0.0"])
       s.add_development_dependency(%q<jeweler>, [">= 1.8.3"])
       s.add_development_dependency(%q<simplecov>, [">= 0"])
     else
+      s.add_dependency(%q<ruby-prof>, [">= 0"])
       s.add_dependency(%q<rspec>, ["< 3", ">= 2.8.0"])
       s.add_dependency(%q<yard>, ["~> 0.7"])
       s.add_dependency(%q<bundler>, [">= 1.0.0"])
@@ -228,6 +235,7 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<simplecov>, [">= 0"])
     end
   else
+    s.add_dependency(%q<ruby-prof>, [">= 0"])
     s.add_dependency(%q<rspec>, ["< 3", ">= 2.8.0"])
     s.add_dependency(%q<yard>, ["~> 0.7"])
     s.add_dependency(%q<bundler>, [">= 1.0.0"])

data/spec/rubylog/builtins/file_system_spec.rb

@@ -37,4 +37,7 @@ describe "file system builtins", :rubylog=>true do
     "./lib/#{A}.rb".file_in("./lib").map{A}.should == ["rubylog"]
   end
 
+  specify "works with nonvars" do
+    "./lib/rubylog.rb".file_in("./lib").to_a.should == [nil]
+  end
 end

data/spec/rubylog/variable_spec.rb

@@ -145,6 +145,20 @@ describe Rubylog::Variable, :rubylog=>true do
     check 3.is(Rubylog::Variable.new(:var1 )).and(4.is(Rubylog::Variable.new(:var1 ))).false
   end
 
+  describe "variables support recursion" do
+    predicate_for Integer, ".factorial()"
+    0.factorial! 1
+    N[thats > 0].factorial(K).if N1.is {N-1} .and N1.factorial(K1).and K.is{ N*K1 }
+
+    check 0.factorial 1
+    check 1.factorial 1
+    check 2.factorial 2
+    check 3.factorial 6
+    check 4.factorial 24
+    check 7.factorial 5040
+  end
+
+
   describe "dont-care variables support recursion" do
     predicate_for Integer, ".factorial()"
     0.factorial! 1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubylog
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-07 00:00:00.000000000Z
+date: 2013-05-16 00:00:00.000000000Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-prof
+  requirement: &79320110 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *79320110
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &80384320 !ruby/object:Gem::Requirement
+  requirement: &79319690 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - <
@@ -24,10 +35,10 @@ dependencies:
         version: 2.8.0
   type: :development
   prerelease: false
-  version_requirements: *80384320
+  version_requirements: *79319690
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &80383710 !ruby/object:Gem::Requirement
+  requirement: &79319150 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -35,10 +46,10 @@ dependencies:
         version: '0.7'
   type: :development
   prerelease: false
-  version_requirements: *80383710
+  version_requirements: *79319150
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &80383340 !ruby/object:Gem::Requirement
+  requirement: &79318590 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -46,10 +57,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *80383340
+  version_requirements: *79318590
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &80382950 !ruby/object:Gem::Requirement
+  requirement: &79318130 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -57,10 +68,10 @@ dependencies:
         version: 1.8.3
   type: :development
   prerelease: false
-  version_requirements: *80382950
+  version_requirements: *79318130
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &80382600 !ruby/object:Gem::Requirement
+  requirement: &79317710 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -68,7 +79,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *80382600
+  version_requirements: *79317710
 description: Rubylog is a Prolog-like DSL for Ruby.
 email: kallo.bernat@gmail.com
 executables: []
@@ -76,7 +87,6 @@ extensions: []
 extra_rdoc_files:
 - LICENSE.txt
 - README.rdoc
-- README.rdoc.orig
 files:
 - .document
 - .rspec
@@ -89,6 +99,12 @@ files:
 - TODO.txt
 - VERSION
 - examples/a_plus_b.rb
+- examples/benchmark.rb
+- examples/benchmark/compiled_not_indexed.rb
+- examples/benchmark/compiled_sequence_indexed.rb
+- examples/benchmark/indexed_procedure.rb
+- examples/benchmark/prolog.rb
+- examples/benchmark/pure.rb
 - examples/checkmate.rb
 - examples/combination.rb
 - examples/dcg.rb
@@ -101,6 +117,7 @@ files:
 - examples/file_search.rb
 - examples/hanoi.rb
 - examples/hello.rb
+- examples/hu/csaladfa.rb
 - examples/mice.rb
 - examples/mice2.rb
 - examples/n_queens.rb
@@ -230,7 +247,6 @@ files:
 - spec/inriasuite_spec.rb
 - spec/integration/custom_classes_spec.rb
 - spec/integration/dsl_spec.rb
-- spec/integration/recursion_spec.rb
 - spec/integration/theory_as_module_spec.rb
 - spec/integration/theory_as_module_with_include_spec.rb
 - spec/rspec/rubylog_spec.rb
@@ -264,7 +280,6 @@ files:
 - spec/rubylog/variable_spec.rb
 - spec/spec_helper.rb
 - vimrc
-- README.rdoc.orig
 homepage: https://github.com/cie/rubylog
 licenses:
 - MIT
@@ -280,7 +295,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -961282381
+      hash: 393356129
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:

data/README.rdoc.orig

@@ -1,284 +0,0 @@
-= Rubylog - Prolog interpreter for ruby
-
-Rubylog is a Prolog-like DSL for Ruby. The language is inspired by {Jamis
-Buck}[http://weblog.jamisbuck.org/2006/10/28/prolog-in-ruby], and the
-implementation is based on {Yield Prolog}[http://yieldprolog.sourceforge.net/],
-with lots of sintactic and semantic additions.
-
-See the {wiki}[https://github.com/cie/rubylog/wiki] for online documentation.
-
-== Getting started
-
-First, install the gem
-
-  $ gem install rubylog
-
-or, if you use +bundler+, add this line to your +Gemfile+:
-
-  gem 'rubylog', '~>2.0pre1'
-
-
-
-First, you need a Rubylog context. The simplest you can do is to extend Rubylog::Context into the main object.
-
-  require 'rubylog'
-  extend Rubylog::Context
-
-
-=== Data types
-
-Rubylog is similar to Prolog, but there are quite a few differences. In Rubylog,
-you can use any Ruby object as data.
-
-Rubylog variables are (undefined) constant names:
-
-  A, B, ANYTHING
-
-A variables whose name starts with +ANY...+ (case-insensitive) is a don't-care
-variable (like +_+ in Prolog).
-
-<<<<<<< HEAD
-Structures are in a different order than they are in prolog:
-
-  functor_for String, :likes
-  'John'.likes('beer')
-
-which would be <tt>likes('John','beer')</tt> in prolog.
-
-=======
->>>>>>> develop
-Lists are just Ruby arrays:
-
-  [1, 2, 3]
-
-They can have splats:
-
-  [1, 2, *T]
-
-Which would be <tt>[1,2|T]</tt> in Prolog, however, in Rubylog, splats are not limited
-to the end.
-
-=== Predicates
-As in prolog, predicates are the buinding blocks of your program. However, the arguments are in a different order than they are in prolog:
-
-  predicate_for String, ".likes()"
-  'John'.likes!('beer')
-
-which would be <tt>likes('John','beer').</tt> in prolog. In Rubylog, predicates must be declared. The string indicating the predicate syntax is <tt>".likes()"</tt>. The format is <tt>:asdf .asdf .asdf() .asdf(,) .asdf(,,)</tt> for predicates with 0,1,2,3,4 arguments.
-
-You can assert a rule with the +if+ method:
-
-  predicate_for String, ".drinks() .has()"
-  X.drinks(Y).if X.has(Y).and X.likes(Y)        
-
-This would be +drinks(X,Y) :- has(X,Y), likes(X,Y)+ in Prolog.
-
-You can assert facts with <tt>if(:true)</tt>, or, as a shorthand you can use the bang
-syntax:
-
-  'John'.likes! 'milk'                         
-
-Bang assertions return their first argument (which is <tt>'John'</tt> in this case), so they can be chained:
-
-  'John'.likes!('beer').has!('beer')
-
-You can also use +unless+:
-
-  predicate_for String, ".good .bad"
-  A.good.unless A.bad              
-
-Nullary predicates are symbols, similar to Prolog:
-
-  'John'.drinks('beer').if :false.and(:cut!).or(:true)
-
-
-
-=== Built-in predicates
-
-Some built-in predicates and their Prolog equivalents:
-
-<<<<<<< HEAD
-  Prolog     Rubylog  
-  ------     -------  
-   true/0    :true    
-   fail/0    :fail    
-   ','/2     .and()
-   ';'/2     .or()
-   '\+'/1    .false   
-   '='/2     .is()      
-   '=/='/2   .is_not()  
-   member/2  .in()      
-   '!'/0     :cut!    
-=======
-  Rubylog  Prolog
-  -------  ------ 
-  :true     true
-  :fail     fail
-  .and()    ,
-  .or()     ;
-  :false    \+
-  .is()     =
-  .is_not() =/=
-  .in()     member
-  :cut!     !
->>>>>>> develop
-
-There are some new ones:
-
-  not_in, all, any, one, none, iff
-
-You can see reference of these in <tt>lib/rubylog/builtins/logic.rb</tt> and <tt>lib/rubylog/builtins/term.rb</tt>
-
-
-See the documentation in <tt>lib/rubylog/builtins/</tt>
-
-=== Unification
-
-In Rubylog, unification works quite the same in Prolog, with the +is+ functor.
-
-  A.is(B)
-
-Using arrays, you can benefit the splats:
-
-  [1,2,3,4].is([A,B,*T])      # [1,2,3,4] = [A,B|T]     in prolog
-  [1,2,3,4].is([*H,*T])       # append(H, T, [1,2,3,4]) in prolog
-
-The +in+ predicate unifies the first argument with any member of the collection:
-
-  4.in([1,2,3,4])
-
-You can use guards:
-
-  A[String].in(["asdf",5,nil]).each { p A }   # outputs "asdf"
-  A[/x/].in(["asdf","xyz"]).each { p A }      # outputs "xyz"
-  A[thats < 5].in([4,5,6]).each { p A }       # outputs 4
-
-=== Moving between Ruby and Rubylog
-==== Running a query
-
-If you want to run a query, you have many different syntaxes:
-
-  prove ('John'.drinks 'beer')  # => true
-  true? ('John'.drinks 'beer')  # => true
-  ('John'.drinks 'beer').true?  # => true
-  'John'.drinks? 'beer'         # => true
-
-==== Enumerations
-
-+Structure+ implements +Enumerable+, and yields the solutions. Within the
-enumeration block, you can access the values of your variables.
-
-  'John'.drinks! 'beer'
-  ('John'.drinks X).each {p X}      # outputs 'beer'
-  ('John'.drinks X).map{X}          # => ['beer']
-  ('John'.drinks X).count           # => 1
-
-==== Procs as predicates
-
-You can invoke Ruby codes in Rubylog rules with a proc:
-
-  'John'.likes(Y).if proc{ Y =~ /ale/ }
-
-or in most cases you can use just a block:
-
-  'John'.likes(Y).if { Y =~ /ale/ }
-
-The predicate succeeds if the block returns a true value.
-
-==== Procs as functions
-
-+is+ and +in+ can take a proc or block argument, which they execute and take its return value:
-
-  X.good.if X.is { 'BEER'.downcase }
-  X.good.if X.in { get_good_drinks() }
-
-==== The two modes of Rubylog
-
-Rubylog has two modes, DSL and native. DSL code is executed only once
-at compile time, and is used for describing the Rubylog program. Native code is
-executed runtime. Any block passed to Rubylog structures native code.
-
-  ('John'.drinks X).and { X != 'beer'}.each { p X }
-  ^^^^^^^^^^^^^^^^^^^^^^              ^^^^^^          dsl mode
-                         ^^^^^^^^^^^^        ^^^^^    native mode
-
-In dsl mode, variables are +Rubylog::Variable+ objects. In native mode,
-variables are substituted with their respecitve value (or +nil+ if they are not
-bound).
-
-All built-in rubylog predicates are clean logical programming predicates witout
-a side-effect. If you want some side-effects, you always go into native mode.
-
-=== Rubylog as a test suite
-
-You can write simple tests using the +check+ method:
-
-  theory do
-    check :true.or :false
-    check A.is(3).and A.in [1,2,3]
-    check { 5+5 == 10 }
-  end
-
-You sould put this file in <tt>"./logic/something\_logic.rb"</tt>. Then you can run it
-with 
-
-  rubylog logic/something_logic.rb
-
-Or you can run all files in <tt>logic/**/*\_logic.rb</tt> with
-
-  rubylog
-
-=== Other built-in libraries
-
-==== File system
-
-You can make some queries on the file system:
-
-  require "rubylog/builtins/file_system"
-
-  theory do
-    check "README".filename_in "."
-
-    X.dirname_in(".").each { puts X }
-  end
-
-
-==== Reflection
-
-You can make some metaprogramming with Rubylog
-
-
-  require "rubylog/builtins/reflection"
-
-  theory do
-    functor_for String, :likes
-
-    check "John".likes("Jane").structure(:likes, ["John", "Jane"])
-
-    "John".likes(X).if X.likes("John")
-    "Jane".likes!("John")
-    check "John".likes("Jane").follows_from "Jane".likes("John")
-
-    "John".likes!("milk")
-    check "John".likes("milk").fact
-    check "John".likes("beer").fact.false
-
-  end
-
-== Contributing
-
-=== To the language
-
-* Post your own examples to the {wiki}[https://github.com/cie/rubylog/wiki/Examples].
-* Improve others' examples.
-* If you have a suggestion for the language, submit an issue.
-
-=== Reporting bugs or requesting features
-
-* Create an issue on the {issue tracker}[https://github.com/cie/rubylog/issues].
-
-== Copyright
-
-Copyright (c) 2013 Bernát Kalló. See LICENSE.txt for
-further details.
-

data/spec/integration/recursion_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-describe "Recursion", :rubylog=>true do
-  predicate_for Integer, ".factorial()"
-  0.factorial! 1
-  N[thats > 0].factorial(K).if N1.is {N-1} .and N1.factorial(K1).and K.is{ N*K1 }
-
-  check 0.factorial 1
-  check 1.factorial 1
-  check 2.factorial 2
-  check 3.factorial 6
-  check 4.factorial 24
-  check 7.factorial 5040
-end