rubylog 0.0.0 → 0.0.1

data/README.rdoc

@@ -7,32 +7,35 @@ Rubylog is an implementation of (part of) the Prolog language as a Ruby DSL. The
 
 == Using
 
-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:
+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
+  :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        # has(john, beer). in Prolog
+  :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
+  :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]
+  (: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/ }
@@ -44,7 +47,7 @@ At most places you can mix native Ruby with Rubylog by using a proc instead of a
 Variable values are passed to the proc, in the order of appearance.
 
 Nullary predicates are just symbols:
-  John.drinks(:beer).if :true.or :false
+  :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] }
@@ -53,34 +56,36 @@ For predicates requiring a simple value as an argument, you can pass a proc that
 
 The Prolog built-in predicates and the Rubylog equivalents (see +Rubylog::Builtins+ for details):
 
-<table>
-<tr><th>Prolog</th><th>Rubylog</th></tr>
-<tr><td>+true+</td><td>+:true+</td></tr>
-<tr><td>+fail+</td><td>+:fail+</td></tr>
-<tr><td>+,+</td><td>+and+, +&+</td></tr>
-<tr><td>+;+</td><td>+or+, +|+</td></tr>
-<tr><td>+!+</td><td>+:cut+</td></tr>
-<tr><td>+->+</td><td>+then+</td></tr>
-<tr><td><tt>\\\+</tt></td><td>+is_false+, +fails+, +not+, +~+</td></tr>
-<tr><td>+repeat+</td><td>+repeat+</td></tr>
-<tr><td>+A=B+</td><td>+A.is B+</td></tr>
-<tr><td><tt>X is Y*5</tt></td><td><tt>X.is{|y|y*5}</tt></td></tr>
-<tr><td></td><td>+proc{|x,y|y===x}+ or +X.matches Y+</td></tr>
-<tr><td>+L=[H|T]+</td><td>+L.splits_to(H,T)+</td></tr>
-<tr><td>+member(A,L)+</td><td>+A.in L+ (+L+ can be any enumerable)</td></tr>
-<tr><td>+write(A)+</td><td>+A._puts+, +A._print+, +A._p+</td></tr>
-<tr><td>+nl+</td><td>+:nl+</td></tr>
-<tr><td><tt>\\\+((A, \\\+ B))</tt></td><td>+A.all B+</td></tr>
-<tr><td><tt>(A,B)->true</tt></td><td>+A.any B+</td></tr>
-<tr><td><tt></tt></td><td>+A.one B+</td></tr>
-<tr><td><tt>\\\+((A,B))</tt></td><td><tt>A.none B</tt></td></tr>
-
-</table>
+  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.

data/VERSION

@@ -1 +1 @@
-0.0.0
+0.0.1

data/rubylog.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rubylog}
-  s.version = "0.0.0"
+  s.version = "0.0.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Bern\303\241t Kall\303\263"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: rubylog
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 29
   prerelease: false
   segments: 
   - 0
   - 0
-  - 0
+  - 1
   segments_generated: true
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors: 
 - "Bern\xC3\xA1t Kall\xC3\xB3"