mini_kraken 0.1.06 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 800d58c5efac32c005931c5a019f4440060728d1061c381bd10f95d554a525b1
-  data.tar.gz: 217448cd67ca952439e81da5c89393ddd57d061d7ca9d5ed310119d1aab32cbf
+  metadata.gz: 672521fbc6627e2767bfe4d6ce38dd66243736fee451e857ec7ef45d0f8905fe
+  data.tar.gz: 6835bb1d91bb6e867417faba0d6904734295f9a7bab612c6a78fcfbcdc41f84a
 SHA512:
-  metadata.gz: e52d5bdc7a34e1b303f2423fd8463766852bd61dc14d77e7bce43bcf653fd43d2331eb8f4bbc1beee13958e4621c9729b728d0cf5bbb5336bd5e277bf859a473
-  data.tar.gz: 75b7a091579f667b41949905861ec314eb6a269ca5316b67df80cbf9f02d6d86ecd1c0ff74d61de3018c802e7c48ff7a2e4719bcb75f0ef45cca0092ebd3cb25
+  metadata.gz: bd5b5b2d2493b4ec8f8293c5f786be1a7739d05bee5d4733d48edb16713d1df4097be5a6e85127c2c90cf395da877b57ef07a607167b8f5bb1732dbc2a367610
+  data.tar.gz: 6661aadbe8bd778283e91f31181651e32296150d282575697fee1f5c240ea46168c5107baf33d9b590d6a449ec89b2f41e69340b81cb9b9e3692954af155083b

data/.travis.yml

@@ -3,5 +3,9 @@ sudo: false
 language: ruby
 cache: bundler
 rvm:
-  - 2.6.3
+  - 2.7.1
+  - 2.6.6
+  - 2.5.8
+  - 2.4.10
+  - jruby-head
 before_install: gem install bundler -v 2.0.2

data/CHANGELOG.md

@@ -1,5 +1,60 @@
+## [0.1.11] - 2020-06-10
+- Supports `defrel`, taht is, the capability to define new relations by combining other relations.
+- Covers frames from "The Reasoned Scheme" book up to frame [1:87]
+
+### New
+- Class `BaseArg` a generalization of goal or goal template argument.
+- Class `DefRelation` A specialization of `Relation` class aimed for user-defined relation.
+- Class `FormalArg` to represent goal template argument(s).
+- Class `FormalRef` an allusion to a formal argument in a goal template.
+- Class `GoalTemplate` a representation of a goal parametrized with formal arguments.
+- Class `KBoolean` a MiniKraken representation of a boolean value.
+
+### CHANGED
+- File `README.md` minor change: added more TODO's.
+
+## [0.1.10] - 2020-06-10
+- Supports frames from "The Reasoned Scheme" book up to frame [1:81]
+
+### New
+- Factory methods `Outcome#failure`, `Outcome#success`
+- Method `Vocabulary#inspect`
+- File `outcome_spec.rb`
+
+### FIXED
+- `Conj2#conjunction` vocabulary wasn't cleared when outcome2 was nil.
+
+## [0.1.09] - 2020-06-06
+- Supports frames from "The Reasoned Scheme" book up to frame [1:76]
+
+### CHANGED
+- Method `FreshEnv#initialize`accepts an array of goals as second argument. This array is transformed into a conjunction of goals.
+- Method `RunStarExpression#initialize` accepts multiple multiple variable names and goals.
+- Method `RunStarExpression#run` can handle solutions with multiple variables.
+
+## [0.1.08] - 2020-05-30
+- Fix of nasty bug (object aliasing) that caused flaky failures in specs.
+
+### FIXED
+- `DuckFiber#resume` each call returns a distinct `Outcome` instance when successful.
+
+## [0.1.07] - 2020-05-23
+- Implementation of `disj2` (two arguments disjunction - or -)
+
+### New
+- Class `Disj2` as subclass of `GoalRelation` that implements the disjunction of two subgoals
+
+### CHANGED
+- Class `Disj2`: common code with `Conj2` class factored out to superclass `GoalRelation`
+- File `cons_cell.rb`: prevent multiple inclusions via different requires
+- Method `Vocabulary#ancestor_walker` now returns an `Enumerator` instead of a `Fiber`.
+
+### FIXED
+- Method `RunStarExpression#run` clear associations and rankings for second and consecutive solmutions
+
+
 ## [0.1.06] - 2020-05-20
-- Implementation of `conj2` (two arguments conjunction)
+- Implementation of `conj2` (two arguments conjunction - and -)
 
 ### New
 - Class `CompositeGoal`

data/README.md

@@ -6,7 +6,7 @@
 ### What is __mini_kraken__ ?   
 An implemention 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.  
+Based on the reference implementation, in Scheme from 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,13 +15,21 @@ ISBN: 9780262535519, (2018), MIT Press.
 - [X] run\*  
 - [X] fresh 
 - [X] conj2  
+- [X] disj2
+- [X] defrel   
 
 ### TODO
-- [ ] disj2  
-- [ ] defrel 
 - [ ] conde  
 - [ ] Occurs check
 
+List-centric relations from Chapter 2
+- [ ] caro
+- [ ] cdro
+- [ ] conso
+- [ ] nullo
+- [ ] pairo
+- [ ] singletono
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/lib/mini_kraken/core/association_walker.rb

@@ -2,7 +2,7 @@
 
 require 'set'
 require_relative 'atomic_term'
-require_relative 'composite_term'
+require_relative 'cons_cell'
 
 module MiniKraken
   module Core

data/lib/mini_kraken/core/base_arg.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module MiniKraken
+  module Core
+    # Abstract class that is a generalization for goal actual arguments or
+    # for arguments of goal template.
+    class BaseArg
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/conj2.rb

@@ -6,81 +6,74 @@ require_relative 'goal'
 require_relative 'goal_relation'
 require_relative 'outcome'
 
-module MiniKraken
-  module Core
-    # The conjunction is a relation that accepts only goal(s) as its two
-    # arguments. It succeeds if and only both its goal arguments succeeds.
-    class Conj2 < GoalRelation
-      include Singleton
+unless MiniKraken::Core.constants(false).include? :Conj2
+  module MiniKraken
+    module Core
+      # The conjunction is a relation that accepts only goal(s) as its two
+      # arguments. It succeeds if and only both its goal arguments succeeds.
+      class Conj2 < GoalRelation
+        include Singleton
 
-      def initialize
-        super('conj2', nil)
-      end
+        def initialize
+          super('conj2', nil)
+        end
 
-      # @param actuals [Array<Term>] A two-elements array
-      # @param anEnv [Vocabulary] A vocabulary object
-      # @return [Fiber<Outcome>] A Fiber that yields Outcomes objects
-      def solver_for(actuals, anEnv)
-        g1, g2 = *validated_args(actuals)
-        Fiber.new { conjunction(g1, g2, anEnv) }
-      end
+        # @param actuals [Array<Term>] A two-elements array
+        # @param anEnv [Vocabulary] A vocabulary object
+        # @return [Fiber<Outcome>] A Fiber that yields Outcomes objects
+        def solver_for(actuals, anEnv)
+          g1, g2 = *validated_args(actuals)
+          Fiber.new { conjunction(g1, g2, anEnv) }
+        end
 
-      # Yields [Outcome, NilClass] result of the conjunction
-      # @param g1 [Goal] First goal argument
-      # @param g2 [Goal] Second goal argument
-      # @param voc [Vocabulary] A vocabulary object
-      def conjunction(g1, g2, voc)
-        # require 'debug'
-        outcome1 = nil
-        outcome2 = nil
-        if g1.relation.kind_of?(Fail) || g2.relation.kind_of?(Fail)
-          Fiber.yield Outcome.new(:"#u", voc)
-        else
-          f1 = g1.attain(voc)
-          loop do
-            outcome1 = f1.resume
-            break unless outcome1
+        # Yields [Outcome, NilClass] result of the conjunction
+        # @param g1 [Goal] First goal argument
+        # @param g2 [Goal] Second goal argument
+        # @param voc [Vocabulary] A vocabulary object
+        def conjunction(g1, g2, voc)
+          # require 'debug'
+          if g1.relation.kind_of?(Fail) || g2.relation.kind_of?(Fail)
+            Fiber.yield Outcome.new(:"#u", voc)
+          else
+            outcome1 = nil
+            outcome2 = nil
+            f1 = g1.attain(voc)
+            loop do
+              outcome1 = f1.resume
+              break unless outcome1
 
-            outcome1.parent = voc unless outcome1.parent
-            if outcome1.successful?
-              f2 = g2.attain(outcome1)
-              loop do
-                outcome2 = f2.resume
-                break unless outcome2
+              outcome1.parent = voc unless outcome1.parent
+              if outcome1.successful?
+                f2 = g2.attain(outcome1)
+                loop do
+                  outcome2 = f2.resume
+                  break unless outcome2
 
-                outcome2.parent = voc unless outcome2.parent
-                if outcome2.successful?
-                  res = Outcome.new(:"#s", voc)
-                  res.merge(outcome1)
-                  res.merge(outcome2)
-                  Fiber.yield res
-                else
-                  Fiber.yield outcome2
+                  outcome2.parent = voc unless outcome2.parent
+                  if outcome2.successful?
+                    res = Outcome.new(:"#s", voc)
+                    res.merge(outcome1)
+                    res.merge(outcome2)
+                    Fiber.yield res
+                  else
+                    Fiber.yield outcome2
+                  end
+                  outcome2.clear
                 end
-                outcome2.clear
+              else
+                Fiber.yield outcome1
+              end
+              if outcome1.successful? && (outcome2&.successful? || outcome2.nil?)
+                voc.clear
               end
-            else
-              Fiber.yield outcome1
             end
-            voc.clear if outcome1&.successful? && outcome2&.successful?
           end
-        end
 
-        Fiber.yield nil
-      end
-
-      private
-
-      def validated_args(actuals)
-        actuals.each do |arg|
-          unless arg.kind_of?(Goal)
-            prefix = 'conj2 expects goal as argument, found a '
-            raise StandardError, prefix + "'#{arg.class}'"
-          end
+          Fiber.yield nil
         end
+      end # class
 
-        actuals
-      end
-    end # class
+      Conj2.instance.freeze
+    end # module
   end # module
-end # module
+end # unless

data/lib/mini_kraken/core/cons_cell.rb

@@ -2,47 +2,53 @@
 
 require_relative 'composite_term'
 
-module MiniKraken
-  module Core
-    class ConsCell < CompositeTerm
-      attr_reader :car
-      attr_reader :cdr
-
-      def initialize(obj1, obj2 = nil)
-        @car = obj1
-        @cdr = obj2
-      end
-
-      def children
-        [car, cdr]
-      end
-
-      # Return true if it is an empty list, otherwise false.
-      # A list is empty, when both car and cdr fields are nil.
-      def null?
-        car.nil? && cdr.nil?
-      end
-
-      def ==(other)
-        return false unless other.respond_to?(:car)
-
-        (car == other.car) && (cdr == other.cdr)
-      end
-
-      def eql?(other)
-        (self.class == other.class) && car.eql?(other.car) && cdr.eql?(other.cdr)
-      end
-
-      def quote(anEnv)
-        return self if null?
-
-        new_car = car.nil? ? nil : car.quote(anEnv)
-        new_cdr = cdr.nil? ? nil : cdr.quote(anEnv)
-        ConsCell.new(new_car, new_cdr)
-      end
-    end # class
-
-    # Constant representing the null (empty) list.
-    NullList = ConsCell.new(nil, nil).freeze
+unless MiniKraken::Core.constants(false).include? :ConsCell
+  module MiniKraken
+    module Core
+      class ConsCell < CompositeTerm
+        attr_reader :car
+        attr_reader :cdr
+
+        def initialize(obj1, obj2 = nil)
+          @car = obj1
+          @cdr = obj2
+        end
+
+        def children
+          [car, cdr]
+        end
+
+        # Return true if it is an empty list, otherwise false.
+        # A list is empty, when both car and cdr fields are nil.
+        def null?
+          car.nil? && cdr.nil?
+        end
+
+        def ==(other)
+          return false unless other.respond_to?(:car)
+
+          (car == other.car) && (cdr == other.cdr)
+        end
+
+        def eql?(other)
+          (self.class == other.class) && car.eql?(other.car) && cdr.eql?(other.cdr)
+        end
+
+        def quote(anEnv)
+          return self if null?
+
+          new_car = car.nil? ? nil : car.quote(anEnv)
+          new_cdr = cdr.nil? ? nil : cdr.quote(anEnv)
+          ConsCell.new(new_car, new_cdr)
+        end
+
+        def append(another)
+          @cdr = another
+        end
+      end # class
+
+      # Constant representing the null (empty) list.
+      NullList = ConsCell.new(nil, nil).freeze
+    end # module
   end # module
-end # module
+end # defined

data/lib/mini_kraken/core/def_relation.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'relation'
+
+module MiniKraken
+  module Core
+    # A relation that is parametrized with generic formal arguments
+    # and a goal template expression.
+    class DefRelation < Relation
+      # @return [Array<FormalArg>] formal arguments of this DefRelation
+      attr_reader :formals
+
+      # @return [GoalTemplate] goal template
+      attr_reader :goal_template
+
+      # @param aName [String] name of def relation
+      # @param aGoalTemplate [GoalTemplate]
+      def initialize(aName, aGoalTemplate, theFormals, alternateName = nil)
+        super(aName, alternateName)
+        @formals = validated_formals(theFormals)
+        @goal_template = validated_goal_template(aGoalTemplate)
+      end
+
+      # Number of arguments for the relation.
+      # @return [Integer]
+      def arity
+        formals.size
+      end
+
+      # @param actuals [Array<Term>] A two-elements array
+      # @param anEnv [Vocabulary] A vocabulary object
+      # @return [Fiber<Outcome>] A Fiber(-like) instance that yields Outcomes
+      def solver_for(actuals, anEnv)
+        goal = goal_template.instantiate(formals, actuals)
+        goal.attain(anEnv)
+      end
+
+      private
+
+      def validated_formals(theFormals)
+        theFormals
+      end
+
+      def validated_goal_template(aGoalTemplate)
+        aGoalTemplate
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/disj2.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require_relative 'duck_fiber'
+require_relative 'fail'
+require_relative 'goal'
+require_relative 'goal_relation'
+require_relative 'outcome'
+
+unless MiniKraken::Core.constants(false).include? :Disj2
+  module MiniKraken
+    module Core
+      # The disjunction is a relation that accepts only goal(s) as its two
+      # arguments. It succeeds if at least one of its goal arguments succeeds.
+      class Disj2 < GoalRelation
+        include Singleton
+
+        def initialize
+          super('disj2', nil)
+        end
+
+        # @param actuals [Array<Term>] A two-elements array
+        # @param anEnv [Vocabulary] A vocabulary object
+        # @return [Fiber<Outcome>] A Fiber that yields Outcomes objects
+        def solver_for(actuals, anEnv)
+          g1, g2 = *validated_args(actuals)
+          Fiber.new { disjunction(g1, g2, anEnv) }
+        end
+
+        # Yields [Outcome, NilClass] result of the disjunction
+        # @param g1 [Goal] First goal argument
+        # @param g2 [Goal] Second goal argument
+        # @param voc [Vocabulary] A vocabulary object
+        def disjunction(g1, g2, voc)
+          # require 'debug'
+          outcome1 = nil
+          outcome2 = nil
+          if g1.relation.kind_of?(Fail) && g2.relation.kind_of?(Fail)
+            Fiber.yield Outcome.new(:"#u", voc)
+          else
+            f1 = g1.attain(voc)
+            loop do
+              outcome1 = f1.resume
+              break unless outcome1
+
+              outcome1.parent = voc unless outcome1.parent
+              if outcome1.successful?
+                Fiber.yield outcome1
+                outcome1.clear
+              end
+            end
+            f2 = g2.attain(voc)
+            loop do
+              outcome2 = f2.resume
+              break unless outcome2
+
+              outcome2.parent = voc unless outcome2.parent
+              if outcome2.successful?
+                Fiber.yield outcome2
+                outcome2.clear
+              end
+            end
+          end
+
+          Fiber.yield nil
+        end
+      end # class
+
+      Disj2.instance.freeze
+    end # module
+  end # module
+end # unless