mini_kraken 0.2.04 → 0.3.00

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96c07c3751d0c46963e19f8e25dc429a77dbd630c22b32018914ccf36f471689
-  data.tar.gz: 26efce2c03a89fd4129c756ce64daa80783cc9bfcebc0358b493076f33ef9434
+  metadata.gz: ceccf4c9ffeb71fc8759bbf1ea1db003d83e9e150df95793de7e729716c9538d
+  data.tar.gz: bab9d4b22a86eec0fcd95955a799a40bfd51c032d05a56b5c2569e0e833b4d2d
 SHA512:
-  metadata.gz: 1df0d6a9397a804e35700aaedb1fcc1ae7fb91a4b3b237ffe138be5cc63b51113d1af5a57f5cd216a41217993dce5dc5186d0690ab992d2eab229995321e7dfb
-  data.tar.gz: d5af2983495e31e77e8947bffeca99a9b88b916208cb511a88e3f0e397ec2f105cd60d333d2663b78c4e943edad9e4c76c8aa7eabd07a94a733e9821d63de305
+  metadata.gz: 5b8dac966209d3209419b2721c67ecd9ec1d1985b0a457877def4e9eda3a305b6952d996e1791436db33f863a046553df1567ef142fc7fe6d5d8092b7d0e2ecd
+  data.tar.gz: 5c99a985287a32d2e6a2c6dbbcabeaea07203e533372183817660eb2259edda6465b4993997b9dcb8dd0db59e0b69772f31409f17a587a3d55381d7f06151a74

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.3.00] - 2020-12-16
+- Version number bump because this is a vast code rewrite
+
+### CHANGED
+- Most classes have been reworked
+- Relation `Equals` has been renamed to `Unify`
+
 ## [0.2.04] - 2020-09-02
 - Intermediate version before vast code rework.
 

data/README.md

@@ -4,10 +4,9 @@
 [![License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)](https://github.com/famished-tiger/mini_kraken/blob/master/LICENSE.txt)
 
 ### What is __mini_kraken__ ?   
-A library containing an implementation of the [miniKanren](http://minikanren.org/)   
-relational programming language in Ruby.
-*miniKanren* is a small language for relational (logic) programming.  
-Based on the reference implementation, in Scheme from the "The Reasoned Schemer" book.   
+A library containing an implementation in Ruby of the [miniKanren](http://minikanren.org/) 
+ language.
+*miniKanren* is a small language for relational (logic) programming as defined in the "The Reasoned Schemer" book.   
 Daniel P. Friedman, William E. Byrd, Oleg Kiselyov, and Jason Hemann: "The Reasoned Schemer", Second Edition,
 ISBN: 9780262535519, (2018), MIT Press.
 
@@ -15,6 +14,7 @@ ISBN: 9780262535519, (2018), MIT Press.
 - Pure Ruby implementation, not a port from another language
 - Object-Oriented design
 - No runtime dependencies
+- Test suite patterned on the examples from the reference book.
 
 ### miniKanren Features
 - [X] ==  
@@ -24,14 +24,14 @@ ISBN: 9780262535519, (2018), MIT Press.
 - [X] conj2  
 - [X] disj2
 - [X] defrel  
-- [X] caro   
+- [X] caro
+- [X] cdro
 
 ### TODO
 
 - [ ] Occurs check
 
-List-centric relations from Chapter 2 
-- [ ] cdro  
+List-centric relations from Chapter 2
 - [ ] conso  
 - [ ] nullo  
 - [ ] pairo  
@@ -65,7 +65,7 @@ require 'mini_kraken' # Load MiniKraken library
 
 extend(MiniKraken::Glue::DSL) # Add DSL method to self (object in context)
 
-result = run_star('q', equals(q, :pea))
+result = run_star('q', unify(q, :pea))
 puts result # => (:pea)
 ```
 
@@ -79,11 +79,11 @@ and satisfying one or more goals to the `run_star method.
 In our example, the `run_star` method instructs `MiniKraken` to find all solutions,  
 knowing that each successful solution:
 - binds a value to the provided variable `q` and
-- meets the goal `equals(q, :pea)`.
+- meets the goal `unify(q, :pea)`.
 
-The goal `equals(q, :pea)` succeeds because the logical variable `q` is _fresh_ (that is,
+The goal `unify(q, :pea)` succeeds because the logical variable `q` is _fresh_ (that is,
   not yet bound to a value) and will be bound to the symbol `:pea` as a side effect
-  of the goal `equals`.
+  of the goal `unify`.
 
 So the above program succeeds and the only found solution is obtained by binding
  the variable `q` to the value :pea. Hence the result of the `puts` method.
@@ -97,11 +97,11 @@ So the above program succeeds and the only found solution is obtained by binding
  extend(MiniKraken::Glue::DSL) # Add DSL method to self (object in context)
 
  # Following miniKanren program fails
- result = run_star('q', [equals(q, :pea), equals(q, :pod)])
+ result = run_star('q', [unify(q, :pea), unify(q, :pod)])
  puts result # => ()
  ```
 In this example, we learn that `run_star` can take multiple goals placed in an array.
-The program fails to find a solution since it is not possible to satisfy the two `equals` goals simultaneously.  
+The program fails to find a solution since it is not possible to satisfy the two `unify` goals simultaneously.  
 In case of failure, the `run_star` returns an empty list represented as `()` in the output.
 
 
@@ -111,7 +111,7 @@ In case of failure, the `run_star` returns an empty list represented as `()` in
 ```ruby
 # In this example and following, one assumes that DSL is loaded as shown in Example 1
 
-result = run_star(['x', 'y'], [equals(:hello, x), equals(y, :world)])
+result = run_star(['x', 'y'], [unify(:hello, x), unify(y, :world)])
 puts result # => ((:hello :world))
 ```
 
@@ -122,8 +122,8 @@ This time, `run_star` takes two logical variables -`x` and `y`- and successfully
  ```ruby
  result = run_star(['x', 'y'],
                    [
-                     disj2(equals(x, :blue), equals(x, :red)),
-                     disj2(equals(y, :sea), equals(:mountain, y))
+                     disj2(unify(x, :blue), unify(x, :red)),
+                     disj2(unify(y, :sea), unify(:mountain, y))
                    ])
  puts result # => ((:blue :sea) (:blue :mountain) (:red :sea) (:red :mountain))
  ```

data/lib/mini_kraken/atomic/all_atomic.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
 
 require_relative 'k_boolean'
+require_relative 'k_string'
 require_relative 'k_symbol'

data/lib/mini_kraken/atomic/atomic_term.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
 require_relative '../core/term'
-require_relative '../core/freshness'
+# require_relative '../core/freshness'
 
 module MiniKraken
   # This module packages the atomic term classes, that is,
-  # the basic MiniKraken datatypes.
+  # the basic datatypes that cannot be decomposed
+  # in MiniKraken into simpler, smaller data values.
   module Atomic
     # An atomic term is an elementary MiniKraken term, a data value
     # that cannot be decomposed into simpler MiniKraken term(s).
@@ -23,27 +24,25 @@ module MiniKraken
         @value.freeze
       end
 
-      # An atomic term is by definition a ground term: since it doesn't contain
-      # any bound variable (in Prolog sense).
-      # @param _env [Vocabulary]
-      # @return [Freshness]
-      def freshness(_env)
-        Core::Freshness.new(:ground, self)
+      # An atomic term, by definition is bound to a definite value.
+      # @param _ctx [Context]
+      # @return [FalseClass]
+      def unbound?(_ctx)
+        false
       end
 
-      # An atomic term is a ground term: by definition it doesn't contain
-      # any fresh variable.
-      # @param _env [Vocabulary]
+      # An atomic term has a definite value, therefore it is not floating.
+      # @param _ctx [Context]
       # @return [FalseClass]
-      def fresh?(_env)
+      def floating?(_ctx)
         false
       end
 
-      # An atomic term is a ground term: by definition it doesn't contain
-      # any (fresh) variable.
-      # @param _env [Vocabulary]
+      # An atomic term is a pinned term: by definition, it has a definite
+      # value.
+      # @param _ctx [Context]
       # @return [TrueClass]
-      def ground?(_env)
+      def pinned?(_ctx)
         true
       end
 
@@ -55,7 +54,7 @@ module MiniKraken
 
       # Treat this object as a data value.
       # @return [AtomicTerm]
-      def quote(_env)
+      def quote(_ctx)
         self
       end
 
@@ -76,6 +75,22 @@ module MiniKraken
       def eql?(other)
         (self.class == other.class) && value.eql?(other.value)
       end
+
+      # Return the list of variable (i_names) that this term depends on.
+      # For atomic terms, there is no such dependencies.
+      # @param _ctx [Core::Context]
+      # @return [Set] an empty set
+      def dependencies(_ctx)
+        Set.new
+      end
+
+      # Make a copy of self with all the variable reference being
+      # replaced by the corresponding value in the Hash.
+      # @param _substitutions [Hash {String => Term}]
+      # @return [Term]
+      def dup_cond(_substitutions)
+        dup
+      end
     end # class
   end # module
 end # module

data/lib/mini_kraken/atomic/k_integer.rb

@@ -8,10 +8,6 @@ module MiniKraken
     # in MiniKraken
     # @note As MiniKraken doesn't support integer values yet, this class is WIP.
     class KInteger < AtomicTerm
-      # @param aValue [Integer] Ruby representation of integer value
-      def initialize(aValue)
-        super(aValue)
-      end
     end # class
   end # module
 end # module

data/lib/mini_kraken/atomic/k_string.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'atomic_term'
+
+module MiniKraken
+  module Atomic
+    # A specialized atomic term that represents a string value
+    # in MiniKraken.
+    class KString < AtomicTerm
+      # Returns a string representing the MiniKraken symbol.
+      # @return [String]
+      def to_s
+        value
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/atomic/k_symbol.rb

@@ -7,12 +7,6 @@ module MiniKraken
     # A specialized atomic term that represents a symbolic value
     # in MiniKraken.
     class KSymbol < AtomicTerm
-      # Initialize a MiniKraken symbol with a given Ruby Symbol value.
-      # @param aValue [Symbol] Ruby representation of symbol value
-      def initialize(aValue)
-        super(aValue)
-      end
-
       # Returns the name or string corresponding to value.
       # @return [String]
       def id2name

data/lib/mini_kraken/composite/all_composite.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'list'
+require_relative 'cons_cell_visitor'

data/lib/mini_kraken/composite/composite_term.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative '../core/term'
-require_relative '../core/freshness'
 
 module MiniKraken
   # This module packages the composite term classes.
@@ -16,28 +15,13 @@ module MiniKraken
         raise NotImplementedError, 'This method must re-defined in subclass(es).'
       end
 
-      # A composite term is fresh when all its members are nil or all non-nil members
-      # are all fresh
-      # A composite term is bound when it is not fresh and not ground
-      # A composite term is a ground term when all its non-nil members are ground.
-      # @param _env [Vocabulary]
-      # @return [Freshness]
-      def freshness(_env)
-         env.freshness_composite(self)
-      end
-
+=begin
       # @param env [Environment]
       # @return [Boolean]
       def fresh?(env)
         env.fresh_value?(self)
       end
-
-      # A composite is ground if all its children are ground
-      def ground?(anEnv)
-        children.all? do |child|
-          child.nil? || child.ground?(anEnv)
-        end
-      end
+=end
     end # class
   end # module
 end # module

data/lib/mini_kraken/composite/cons_cell.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
+require 'set'
+
 require_relative 'composite_term'
+require_relative 'cons_cell_visitor'
 
 module MiniKraken
   module Composite
     # In Lisp dialects, a cons cell (or a pair) is a data structure with two
-    # fields called the car and cdr fields (for historical reasons).
+    # fields named car and cdr (for historical reasons).
     # Cons cells are the key ingredient for building lists in Lisp.
     # A cons cell can be depicted as a box with two parts, car and cdr each
     # containing a reference to another object.
@@ -43,6 +46,10 @@ module MiniKraken
       attr_reader :cdr
 
       # Construct a new conscell whose car and cdr are obj1 and obj2.
+      # In Scheme, a list is terminated by a null list.
+      # In MiniKraken, a list is terminated by a Ruby nil.
+      # Therefore, when setting the cdr to the null list, the implementation
+      # will silently replace the null list by a nil.
       # @param obj1 [Term, NilClass]
       # @param obj2 [Term, NilClass]
       def initialize(obj1, obj2 = nil)
@@ -55,6 +62,12 @@ module MiniKraken
         end
       end
 
+      # Specialized constructor for null list.
+      # @return [ConsCell] Null list
+      def self.null
+        new(nil, nil)
+      end
+
       def children
         [car, cdr]
       end
@@ -66,7 +79,30 @@ module MiniKraken
         car.nil? && cdr.nil?
       end
 
-      # Return true if car and cdr fields have the same values as the other 
+      # Is the receiver an unbound variable?
+      # By definition, a composite isn't a variable.
+      # @param _ctx [Core::Context]
+      # @return [FalseClass]
+      def unbound?(_ctx)
+        false
+      end
+
+      # Does the composite have a variable that is itself floating?
+      # @return [Boolean]
+      def floating?(ctx)
+        !pinned?(ctx)
+      end
+
+      # Does the composite have a definite value?
+      # @return [Boolean]
+      def pinned?(ctx)
+        @pinned_car ||= car.nil? || car.pinned?(ctx)
+        @pinned_cdr ||= cdr.nil? || cdr.pinned?(ctx)
+
+        @pinned_car && @pinned_cdr
+      end
+
+      # Return true if car and cdr fields have the same values as the other
       # ConsCell.
       # @param other [ConsCell]
       # @return [Boolean]
@@ -75,17 +111,17 @@ module MiniKraken
 
         (car == other.car) && (cdr == other.cdr)
       end
-      
+
       # Test for type and data value equality.
       # @param other [ConsCell]
-      # @return [Boolean]      
+      # @return [Boolean]
       def eql?(other)
         (self.class == other.class) && car.eql?(other.car) && cdr.eql?(other.cdr)
       end
 
       # Return a data object that is a copy of the ConsCell
       # @param anEnv [Core::Environment]
-      # @return [ConsCell]      
+      # @return [ConsCell]
       def quote(anEnv)
         return self if null?
 
@@ -102,11 +138,142 @@ module MiniKraken
         "(#{pair_to_s})"
       end
 
-      # Change the cdr of ConsCell to 'another'.
+      # Return the list of variable (i_names) that this term depends on.
+      # For a variable reference, it will return the i_names of its variable
+      # @param ctx [Core::Context]
+      # @return [Set<String>] A set of i_names
+      def dependencies(ctx)
+        deps = []
+        visitor = ConsCellVisitor.df_visitor(self)
+        skip_children = false
+        loop do
+          side, cell = visitor.resume(skip_children)
+          if cell.kind_of?(Core::LogVarRef)
+            deps << ctx.lookup(cell.name).i_name
+            skip_children = true
+          else
+            skip_children = false
+          end
+          break if side == :stop
+        end
+
+        Set.new(deps)
+      end
+
+      # @param ctx [Core::Context]
+      # @param theSubstitutions [Hash{String => Association}]
+      def expand(ctx, theSubstitutions)
+        head = curr_cell = nil
+        path = []
+
+        visitor = ConsCellVisitor.df_visitor(self) # Breadth-first!
+        skip_children = false
+
+        loop do
+          side, cell = visitor.resume(skip_children)
+          # next if cell == self
+          break if side == :stop
+
+          case cell
+            when ConsCell
+              new_cell = ConsCell.null
+              if curr_cell
+                curr_cell.set!(side, new_cell)
+                path.push(curr_cell)
+              end
+              curr_cell = new_cell
+              head ||= new_cell
+
+            when Core::LogVarRef
+              # Is this robust?
+              if cell.i_name
+                i_name = cell.i_name
+              else
+                i_name = ctx.symbol_table.lookup(cell.name).i_name
+              end
+              expanded = ctx.expand_value_of(i_name, theSubstitutions)
+              curr_cell.set!(side, expanded)
+              curr_cell = path.pop if side == :cdr
+
+            else
+              curr_cell.set!(side, cell)
+              curr_cell = path.pop if side == :cdr
+          end
+        end
+
+        head
+      end
+
+
+      # @param ctx [Core::Context]
+      # @param theSubstitutions [Hash{String => Association}]
+
+
+      # File 'lib/mini_kraken/atomic/atomic_term.rb', line 91
+      # Make a copy of self with all the variable reference being replaced
+      # by the corresponding value in the Hash.
+      # @param substitutions [Hash {String => Term}]
+      # @return [ConsCell]
+      def dup_cond(substitutions)
+        head = curr_cell = nil
+        path = []
+
+        visitor = ConsCellVisitor.df_visitor(self) # Breadth-first!
+        skip_children = false
+
+        loop do
+          side, cell = visitor.resume(skip_children)
+          # next if cell == self
+          break if side == :stop
+
+          if cell.kind_of?(ConsCell)
+            new_cell = ConsCell.null
+            if curr_cell
+              curr_cell.set!(side, new_cell)
+              path.push(curr_cell)
+            end
+            curr_cell = new_cell
+            head ||= new_cell
+
+          else
+            duplicate = cell.nil? ? nil : cell.dup_cond(substitutions)
+            curr_cell.set!(side, duplicate)
+            curr_cell = path.pop if side == :cdr
+          end
+        end
+
+        head
+      end
+
+      # Set one element of the pair
+      # @param member [Symbol]
+      # @param element [Term]
+      def set!(member, element)
+        case member
+          when :car
+            set_car!(element)
+          when :cdr
+            @pinned_cdr = nil
+            @cdr = element
+          else
+            raise StandardError, "Undefined cons cell member #{member}"
+          end
+      end
+
+      # Change the car of ConsCell to 'element'.
+      # Analogue of set-car! procedure in Scheme.
+      # @param element [Term]
+      def set_car!(element)
+        @pinned_car = nil # To force re-evaluation
+        @car = element
+      end
+
+      # Change the cdr of ConsCell to 'element'.
       # Analogue of set-cdr! procedure in Scheme.
-      # @param another [Term]
-      def set_cdr!(another)
-        @cdr = another
+      # @param element [Term]
+      def set_cdr!(element)
+        @pinned_cdr = nil # To force re-evaluation
+        @cdr = (element.kind_of?(ConsCell) && element.null?) ? nil : element
       end
 
       protected
@@ -126,7 +293,7 @@ module MiniKraken
       end
     end # class
 
-    # Constant representing the null (empty) list.
-    NullList = ConsCell.new(nil, nil).freeze
+    # Constant set to a null (empty) list.
+    NullList = ConsCell.null.freeze
   end # module
 end # module