rubylog 0.0.1 → 1.0.0

data/Gemfile

@@ -12,7 +12,7 @@ group :development do
   gem "cucumber", ">= 0"
   gem "bundler", "~> 1.0.0"
   gem "jeweler", "~> 1.8.3"
-  gem "simplecov"
+  gem "simplecov", :require => false
   gem "reek", "~> 1.2.8"
   gem "roodi", "~> 2.1.0"
 end

data/README.hu.rb

@@ -0,0 +1,58 @@
+# Rubylog
+
+# A Rubylog a Prologhoz hasonló programozási nyelv.
+
+# A Prolog program alapköve a funktorból és argumentumokból álló term:
+likes("John", "beer")
+
+# A Rubylog programban a funktor az első argumentum után áll:
+"John".likes("beer")
+
+# A prolog programot tények és szabályok alkotják.
+likes("John", "beer").
+drinks(X,D) :- likes(X,D).
+
+# Rubylogban hasonlóan, a tényeket ! jelzi, a szabályokat 'if'
+"John".likes! "beer"
+X.drinks(D).if X.likes(D)
+
+# A nulláris predikátumok a Rubylogban szimbólumok:
+:true
+:fail
+:cut!
+
+# A Prolog operátorok helyett Rubylogban sokszor szavakat használunk:
+#  Prolog   Rubylog
+     :-        if
+     ,         and
+     ;         or
+     \+        false
+     =         is
+
+# A jobb hangzás érdekében néhány Prolog beépített predikátum neve más
+# Rubylogban
+#  Prolog   Rubylog
+     member    in
+# HAsonlít de többet tud
+
+# Vannak
+     all
+     any
+     one
+     none
+
+     # Reflection
+     list structure follows_from
+
+
+# Azért nem vezettünk be
+     {a:b}.is {a}
+     {}.isnt {a:b}
+# -t, mert akkor nem lenne kummutatív az unifikáció, és az egyáltalán nem POLA.
+# Azért nem vezettünk be
+     {a:b}.is {}
+# -t, mert az nagyon bonyolult, és nem POLA. Ezért marad
+     {a:b}.is {a:b}
+# és lehet
+     {a:b}.merge!(X)
+# akár.

data/README.rdoc

@@ -1,101 +1,260 @@
 = Rubylog - Prolog interpreter for ruby
 
-Rubylog is an implementation of (part of) the Prolog language as a Ruby DSL. The DSL 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/].
+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.
+
+== Getting started
+
+First, install the gem
 
-== Installing
   $ gem install rubylog
 
-== Using
+or, if you use +bundler+, add this line to your +Gemfile+:
+
+  gem 'rubylog', '~>1.0.0'
+
+
+
+First, you have to create a theory and write your code in the block given to it:
 
-To get started you have to do three things: require rubylog, include Rubylog::DSL::Constants and declare some functors on a class you want to use:
   require 'rubylog'
-  include Rubylog::DSL::Constants
-  Symbol.rubylog_functor :likes, :drinks, :has
-
-A Rubylog clause can be created by sending the functor to the first argument, passing the other arguments:
-  :john.likes :beer       # likes(john,beer) in Prolog
-
-A variable is an undefined constant. Don't-care variables start with ANY...
-  A, B, Cat               # the same in Prolog
-  ANY, ANYONE, ANYTHING   # _ in Prolog
-
-Now you can start writing Rubylog predicates. Facts can be asserted with a bang:
-  :john.likes! :beer      # likes(john, beer). in Prolog
-  :john.has! :beer      
-
-Fact assertions return the first argument, so they can be chained:
-  :john.likes!(:beer).has!(:beer)
-
-Rules can be asserted with +if+ and +unless+:
-  X.drinks(Y).if X.has(Y).and X.likes(Y)         # drinks(X,Y) :- has(X,Y), likes(X,Y). in Prolog
-
-Queries can be proved with a question mark or with +true?+:
-  :john.drinks? :beer         # => true
-  (:john.drinks :beer).true?  # => true
-
-Or solutions can be enumerated (clauses include Enumerable)
-  (:john.drinks X).each {|x| p x}  # outputs :beer
-  (:john.drinks X).to_a            # => [:beer]
-
-At most places you can mix native Ruby with Rubylog by using a proc instead of a clause. Blocks are automatically converted to proc objects:
-  X.drinks(Y).if proc{|x,y| y.to_s =~ /^Z/ }
-  X.drinks(Y).if {|x,y| y.to_s =~ /^Z/ }     # the same
-
-  X.drinks(Y).if X.likes(Y).and proc { Time.now.hour == 12 }
-  X.drinks(Y).if X.likes(Y).and { Time.now.hour == 12 }     # the same
-
-Variable values are passed to the proc, in the order of appearance.
-
-Nullary predicates are just symbols:
-  :john.drinks(:beer).if :true.or :false
-
-For predicates requiring a simple value as an argument, you can pass a proc that returns that value
-  X.drinks(Y).if Y.is proc{|x| $favorites[x] }
-  X.drinks(Y).if Y.is {|x| $favorites[x] }      # the same
-
-
-The Prolog built-in predicates and the Rubylog equivalents (see +Rubylog::Builtins+ for details):
-
-  Prolog              Rubylog
-  ----------------------------------------
-  true                true
-  fail                fail
-  ,                   and, &
-  ;                   or, |
-  !                   :cut
-  ->                  then
-  \+                  is_false, fails, not, ~
-  repeat              repeat
-  A=B                 A.is B
-  X is Y*5            X.is{|y|y*5}
-                      proc{|x,y|y===x} or X.matches Y
-  L=[H|T]             L.splits_to(H,T)
-  member(A,L)         A.in L (L can be any enumerable)
-  write(A)            A._puts, A._print, A._p
-  nl                  nl
-  \+((A, \+ B))       A.all B
-  (A,B)->true         A.any B
-                      A.one B
-  \+((A,B))           A.none B
-  A,fail;true         A.all
-  A->true             A.any
-                      A.one
-  \+(A)               A.none
-
-
-
-
-== Contributing to rubylog
-* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
-* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
-* Fork the project.
-* Start a feature/bugfix branch.
-* Commit and push until you are happy with your contribution.
-* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
-* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+  MyTheory = theory do
+    # your code here
+  end
+
+All further examples in this file should be written within the +theory+ block.
+
+
+=== 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).
+
+Structures are in a different order than they are in prolog:
+
+  functor_for String, :likes
+  'John'.likes('beer')
+
+which would be +likes('John','beer')+ in prolog.
+
+Lists are just Ruby arrays:
+
+  [1, 2, 3]
+
+They can have splats:
+
+  [1, 2, *T]
+
+Which would be +[1,2|T]+ in Prolog, however, in Rubylog, splats are not limited
+to the end.
+
+=== Predicates
+
+You can assert a rule with the +if+ method:
+
+  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 +if(:true)+, or, as a shorthand you can use the bang
+syntax:
+
+  'John'.likes! 'milk'                         
+
+Bang assertions return their first argument (which is +'John'+ in this case), so they can be chained:
+
+  'John'.likes!('beer').has!('beer')
+
+You can also use +unless+:
+
+  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:
+
+  Rubylog  Prolog
+  -------  ------ 
+  :true     true
+  :fail     fail
+  .and      ,
+  .or       ;
+  :false    \+
+  .is       =
+  .is_not   =/=
+  .in       member
+  :cut!     !
+
+There are some new ones:
+
+  is_not, not_in, all, any, one, none, iff
+
+=== 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-effect, you always go into native mode.
+
+=== Rubylog as a test suite
+
+You can write simple tests using the +check+ method:
+
+  theory do
+    check :true
+    check { 5+5 == 10 }
+  end
+
+You sould put this file in +"./logic/something\_logic.rb"+. Then you can run it
+with 
+
+  rubylog logic/something_logic.rb
+
+Or you can run all files in +logic/**/*_logic.rb+ 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
+* Create an issue on the {issue tracker}[https://github.com/cie/rubylog/issues].
+* We will discuss it.
+* Maybe I'll introduce it.
+
+=== To the implementation
+* Create an issue on the {issue tracker}[https://github.com/cie/rubylog/issues].
+* We will discuss it.
+* Maybe I'll implement it.
+* If not, fork the project.
+* Implement it.
+* Have fun.
+* Post a pull request.
 
 == Copyright
 
-Copyright (c) 2012 Bernát Kalló. See LICENSE.txt for
+Copyright (c) 2013 Bernát Kalló. See LICENSE.txt for
 further details.
 

data/Rakefile

@@ -21,6 +21,7 @@ Jeweler::Tasks.new do |gem|
   gem.description = %Q{Rubylog is an embedded Prolog language and interpreter for Ruby.}
   gem.email = "kallo.bernat@gmail.com"
   gem.authors = ["Bernát Kalló"]
+  gem.executables = Dir["bin/*"].map{|x|File.basename x}
   # dependencies defined in Gemfile
 end
 Jeweler::RubygemsDotOrgTasks.new
@@ -47,7 +48,11 @@ RoodiTask.new do |t|
   t.verbose = false
 end
 
-task :default => :spec
+task :logic do
+  run "ruby"
+end
+
+task :default => :logic
 
 require 'yard'
 YARD::Rake::YardocTask.new

data/VERSION

@@ -1 +1 @@
-0.0.1
+1.0.0

data/bin/rubylog

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+require "./lib/rubylog"
+
+files = ARGV.empty? ?  Dir['./logic/**/*_logic.rb'] : Dir[*ARGV].map{|f| File.expand_path f }
+ARGV.clear
+
+
+files.each do |x|
+  puts x
+
+  require x
+
+  puts
+end
+
+
+
+

data/examples/dcg.rb

@@ -0,0 +1,35 @@
+# This is a quick and dirty solution to replace Prolog's DCG syntax.
+# It is slow for long inputs. See examples/dcg2.rb for a more efficient algorithm (the same as Prolog's DCG).
+
+theory do
+  functor_for Array, :sentence, :subject, :object, :nominal_phrase, :noun, :verb, :article
+
+  [*S,*V,*O].sentence.if S.subject.and V.verb.and O.object
+  S.subject.if S.nominal_phrase
+  O.object .if O.nominal_phrase
+  [*A,*N].nominal_phrase.if A.article.and N.noun
+
+  %w(a).article!
+  %w(the).article!
+
+  %w(dog).noun!
+  %w(cat).noun!
+  %w(mouse).noun!
+
+  %w(chases).verb!
+  %w(eats).verb!
+
+  def check_passed goal; end
+
+  check %w(dog).noun
+  check %w(a dog).nominal_phrase
+  check %w(dog).nominal_phrase.false
+  check %w(the dog chases a cat).sentence
+  check %w(the dog chases a cat stuff).sentence.false
+  check %w(dog chases cat).sentence.false
+  check { %W(the #{S} chases the #{O}).sentence.map{[S,O]}.count == 9 }
+
+  puts *S.sentence.map{S.join(" ")}
+
+
+end

data/examples/dcg2.rb

@@ -0,0 +1,42 @@
+# This is an example of the same algorithm that Prolog's DCG syntax generates.
+#
+
+$:.unshift File.dirname(__FILE__)+"/../lib"
+require 'rubylog'
+
+theory do
+  functor_for Array, :sentence, :subject, :object, :nominal_phrase, :noun, :verb, :article
+
+  # sentence --> subject, verb, object
+  Se.sentence(L3).if Se.subject(L1).and L1.verb(L2).and L2.object(L3)
+  # subject --> nominal_phrase
+  S.subject(L1).if S.nominal_phrase(L1)
+  # object --> nominal_phrase
+  O.object(L1) .if O.nominal_phrase(L1)
+  # nominal_phrase --> article, noun
+  N.nominal_phrase(L2).if N.article(L1).and L1.noun(L2)
+
+  ["a",*L1].article! L1
+  ["the",*L1].article! L1
+
+  ["dog",*L1].noun! L1
+  ["cat",*L1].noun! L1
+  ["mouse",*L1].noun! L1
+
+  ["chases",*L1].verb! L1
+  ["eats",*L1].verb! L1
+
+  def check_passed goal; end
+
+  check %w(dog).noun([])
+  check %w(a dog).nominal_phrase([])
+  check %w(dog).nominal_phrase(ANY).false
+  check %w(the dog chases a cat).sentence([])
+  check %w(the dog chases a cat stuff).sentence(["stuff"])
+  check %w(dog chases cat).sentence(ANY).false
+  check { %W(the #{S} chases the #{O}).sentence([]).map{[S,O]}.count == 9 }
+
+  puts *S.sentence([]).map{S.join(" ")}
+
+
+end

data/examples/enumerators.rb

@@ -0,0 +1,30 @@
+$:.unshift File.dirname(__FILE__)+"/../lib"
+require 'rubylog'
+
+theory do
+  subject Symbol
+  functor :likes
+
+  :john.likes! :beer
+  :john.likes! :milk
+  :john.likes! :water
+
+  :jane.likes! :milk
+  :jane.likes! :water
+
+  :jeff.likes! :water
+  :jeff.likes! :milk
+  :jeff.likes! :juice
+
+  check A.likes(:beer).all A.likes(:water)
+  check A.likes(:beer).any A.likes(B).and B.is_not :water
+  check A.likes(:milk).iff A.likes(:water)
+  check A.likes(:beer).iff A.is(:john)
+
+  check all(X.likes(:juice), X.likes(:beer).false)
+  check any(X.likes(:water), X.likes(:juice))
+  check one(X.likes :juice)
+  check one(X.likes :milk).false
+  check none(X.likes :palinka)
+  check iff A.likes(:milk), A.likes(:water)
+end

data/examples/factorial.rb

@@ -1,16 +1,17 @@
+$:.unshift File.dirname(__FILE__)+"/../lib"
 require 'rubylog'
 
-class << FactorialTheory = Rubylog::Theory.new!
+FactorialTheory = theory do
+  subject Integer
+  functor :factorial
 
   0.factorial! 1
-  N.factorial(K).if proc{|n|n>0}.and N1.is{|n|n-1}.and N1.factorial(K1).and K.is{|n,_,_,k1| n*k1}
-
-  [0,1,2,7].each do |n|
-    (n.factorial? K).solve{|k| puts "#{n} factorial is #{k}"}
-  end
-
-  Integer.include_theory self
+  N[thats > 0].factorial(K).if \
+    N1.is{N-1}.
+    and N1.factorial(K1).
+    and K.is{N*K1}
 
+  7.factorial(N).solve {puts N}
 end
 
 

data/examples/hanoi.rb

@@ -0,0 +1,24 @@
+$:.unshift File.dirname(__FILE__)+"/../lib"
+require "rubylog"
+
+theory do
+  functor_for Integer, :move, :hanoi
+  prefix_functor :write_info
+
+  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?"
+  prove 1.hanoi
+
+  puts "\n\nWhat's the solution for 5 discs?"
+  prove 5.hanoi
+
+
+end

data/examples/hello.rb

@@ -1,9 +1,15 @@
-require "rubylog"
+$:.unshift File.dirname(__FILE__)+"/../lib"
 
-Rubylog.use :variables, :implicit_predicates, String
+require 'rubylog'
 
-A.write.if {|a| puts a; true}
-:hello.if "Hello, world!".write
 
-:hello.true?
+HelloTheory = theory do
+  functor_for String, :written
+
+  X.written.if {puts X; true}
+
+  :hello.if "Hello, world!".written
+end
+
+HelloTheory.prove :hello
 

data/examples/parsing.rb

@@ -0,0 +1,27 @@
+require "readline"
+
+theory do
+  functor_for String, :term, :expr, :atom
+
+  "#{A}+#{B}".expr(K).if A.term(I).and B.expr(J).and K.is{I+J}
+  "#{A}-#{B}".expr(K).if A.term(I).and B.expr(J).and K.is{I-J}
+  A.expr(K).if A.term(K)
+  "#{A}*#{B}".term(K).if A.atom(I).and B.term(J).and K.is{I*J}
+  "#{A}/#{B}".term(K).if A.atom(I).and B.term(J).and K.is{I/J}
+  A.term(K).if A.atom(K)
+  A[/\A[0-9]+\z/].atom(K).if K.is{A.to_i}
+  "(#{A})".atom(K).if A.expr(K)
+
+  check "5".expr(5)
+  check "5+3*2".expr(11)
+  check "1+2+3+4".expr(10)
+  check "(5+3)/2".expr(4)
+  check "(5+3(5)/2".expr(ANY).false
+
+  puts
+  while k = Readline.readline("> ", true)
+    k.chomp!
+    puts k.expr(X).map{X}.first || "error"
+  end
+
+end