mini_kraken 0.1.07 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15536181da18de42e83ec948742a97c63338f2065841849de64d3537eeeb9bc1
-  data.tar.gz: bb25b2bfcab17da55d5dfa6845e699fa2a48e89e19956f3c63f2e755577d4ae7
+  metadata.gz: ca30db7b93b0232f1df5321a1e00270395d908e3f7be1d24d3d5a9c19c833914
+  data.tar.gz: d64051987c0b09abf752b24604854515cabc9e99ff5ee436884c8522d6a75950
 SHA512:
-  metadata.gz: a964e66c182fa2d834007c2003fa7b16b0e91d8cc80f8525de9c95df89d81523a9a2e93c7e57c2a96605ce6af5244324d5a7bf80c877d46a8a647726a3ac1e49
-  data.tar.gz: 6608b250a6949ce6d7f3fd4c548c7525595fc20c808b5fa327b2cdc1b48ac5b37dd05ee92ae4a8ea2e9a5f76477c24afd5b20e6d1851061afca43952f8d75949
+  metadata.gz: f4fc60b256907317972c51410e52aec821553d7575c24d59b9421f4ba8dbd0136937e70ffb2f9f21556ed205b8b8d54796af68c222df0704b45ebbcf562c3ab3
+  data.tar.gz: 5caf5af0c016e8dfb5de40244ad71a083eb035e0bcb911ae7bd90e67a784789458c12e46a3cc75a96ae483fd0317d86b6610a7c339cd423050b4d57e642d6cc9

data/CHANGELOG.md

@@ -1,3 +1,53 @@
+## [0.1.12] - 2020-06-29
+- Supports `conde`, that is, a relation that can take an arbitrary number of arguments.
+- Cover all frames but one from Chapter One of "Reasoned Scheme" book.
+
+### New
+- Class `Conde` a relation that succeeds for each of its successful arguments.
+
+### CHANGED
+- Method `Goal#validated_actuals` add into account polyadic relations (= relations with arbitrary number of arguments)
+
+## [0.1.11] - 2020-06-25
+- Supports `defrel`, that 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-13
+- 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 -)
 

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] disj2
+- [X] defrel   
 
 ### TODO
-- [ ] 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/conde.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require_relative 'conj2'
+require_relative 'duck_fiber'
+require_relative 'fail'
+require_relative 'goal'
+require_relative 'goal_relation'
+require_relative 'outcome'
+
+unless MiniKraken::Core.constants(false).include? :Conde
+  module MiniKraken
+    module Core
+      # A polyadic relation (i.e. it can takes an arbitrary number of argumentt)
+      # that behaves as the disjunction of its arguments.
+      # It succeeds if at least one of its goal arguments succeeds.
+      class Conde < GoalRelation
+        include Singleton
+
+        def initialize
+          super('conde', nil)
+        end
+
+        # A relation is polyadic when it accepts an arbitrary number of arguments.
+        # @return [TrueClass]
+        def polyadic?
+          true
+        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)
+          args = *validated_args(actuals)
+          Fiber.new { cond(args, anEnv) }
+        end
+
+        # Yields [Outcome, NilClass] result of the disjunction
+        # @param goals [Array<Goal>] Array of goals
+        # @param voc [Vocabulary] A vocabulary object
+        def cond(goals, voc)
+          # require 'debug'
+          success = false
+
+          goals.each do |g|
+            fiber = nil
+
+            case g
+              when Core::Goal
+                fiber = g.attain(voc)
+              when Core::Environment
+                fiber = g.attain(voc)
+              when Array
+                conjunct = conjunction(g)
+                fiber = conjunct.attain(voc)
+              when Core::ConsCell
+                goal_array = to_goal_array(g)
+                conjunct = conjunction(goal_array)
+                fiber = conjunct.attain(voc)
+            end
+            loop do
+              outcome = fiber.resume
+              break unless outcome
+
+              outcome.parent = voc unless outcome.parent
+              if outcome.successful?
+                success = true
+                Fiber.yield outcome
+                outcome.clear
+              end
+            end
+          end
+
+          Fiber.yield Outcome.new(:"#u", voc) unless success
+          Fiber.yield nil
+        end
+
+        private
+
+        def validated_args(actuals)
+          result = []
+
+          actuals.each do |arg|
+            case arg
+              when Core::Goal
+                result << arg
+
+              when Core::Environment
+                result << arg
+
+              when Array
+                result << validated_args(arg)
+
+              else
+                prefix = "#{name} expects goal as argument, found a "
+                raise StandardError, prefix + "'#{arg.class}'"
+            end
+          end
+
+          result
+        end
+
+        def conjunction(goal_array)
+          result = nil
+
+          loop do
+            conjunctions = []
+            goal_array.each_slice(2) do |uno_duo|
+              if uno_duo.size == 2
+                conjunctions << Core::Goal.new(Core::Conj2.instance, uno_duo)
+              else
+                conjunctions << uno_duo[0]
+              end
+            end
+            if conjunctions.size == 1
+              result = conjunctions[0]
+              break
+            end
+            goal_array = conjunctions
+          end
+
+          result
+        end
+
+        def to_goal_array(aCons)
+          array = []
+          curr_node = aCons
+          loop do
+            array << curr_node.car if curr_node.car.kind_of?(Core::Goal)
+            break unless curr_node.cdr
+            break unless curr_node.car.kind_of?(Core::Goal)
+
+            curr_node = curr_node.cdr
+          end
+
+          array
+        end
+      end # class
+
+      Conde.instance.freeze
+    end # module
+  end # module
+end # unless

data/lib/mini_kraken/core/conj2.rb

@@ -6,68 +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
+
+          Fiber.yield nil
         end
+      end # class
 
-        Fiber.yield nil
-      end
-    end # class
+      Conj2.instance.freeze
+    end # module
   end # module
-end # module
+end # unless

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

@@ -2,66 +2,71 @@
 
 require 'singleton'
 require_relative 'duck_fiber'
+require_relative 'fail'
 require_relative 'goal'
 require_relative 'goal_relation'
 require_relative 'outcome'
 
-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
+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
+        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
+        # @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
+        # 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
+              outcome1.parent = voc unless outcome1.parent
+              if outcome1.successful?
+                Fiber.yield outcome1
+                outcome1.clear
+              end
             end
-          end
-          f2 = g2.attain(voc)
-          loop do
-            outcome2 = f2.resume
-            break unless outcome2
+            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
+              outcome2.parent = voc unless outcome2.parent
+              if outcome2.successful?
+                Fiber.yield outcome2
+                outcome2.clear
+              end
             end
           end
+
+          Fiber.yield nil
         end
+      end # class
 
-        Fiber.yield nil
-      end
-    end # class
+      Disj2.instance.freeze
+    end # module
   end # module
-end # module
+end # unless