mini_kraken 0.1.08 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32a6f92773457338343dffa1343906883ffdbafbf7f8fd9ace170062cc34d345
-  data.tar.gz: cb7d3e6b88f8bea952bea7f214eaf73af97857de6958f65592a15b7ee7ef2510
+  metadata.gz: 79ea33dd475e6dfbed71915177b1581abb5e1ca9a60db04133d11cda7dca9d42
+  data.tar.gz: 249bea4319183c929e4c291785c6b74e10606889c789c5e0f2b211197cc6f288
 SHA512:
-  metadata.gz: db730590bcc99203f8983fe19b5e0d0b90c77819c07875bc34c100bc843c9b3e5e3e148833149d3264847a190cc9ce5bcf1fa31f74723b8c8e8006a56948d738
-  data.tar.gz: 4cb5cb8f327e7cb81028621ad67e36afecee8bc90beac1cd6449573b85092191d39d55dfbe2de9f52a5868a66bf4c8288a3223b41815528fb651eead36d3f4fa
+  metadata.gz: '086bf0b30750e908dfee1b7e95eb3b0c0e54dff4f7bd700d54bbf28091aaf02080d458c14508ddcaa580248e0234d1da23553869480e3bea930d46708c115d82'
+  data.tar.gz: d3ada8d056819b2ae1af0d442056008600f82633ee52ca8aa672708943fdf517adb60522bfff6673f9cea86985c1bf5ce2a7a3ea73f07504945e660f31ebee49

data/CHANGELOG.md

@@ -1,3 +1,55 @@
+## [0.1.13] - 2020-07-01
+- Cover all frames from Chapter One of "Reasoned Scheme" book.
+- Fix defect for fused variables that remain fresh
+
+### CHANGED
+- Method `Variable#quote` now takes into account of cases when variables are fused.
+- Method `Vocabulary#names_fused`  now copes with cases where no variable with given name can be found.
+
+## [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.
 

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

@@ -32,11 +32,11 @@ unless MiniKraken::Core.constants(false).include? :Conj2
         # @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
+            outcome1 = nil
+            outcome2 = nil
             f1 = g1.attain(voc)
             loop do
               outcome1 = f1.resume
@@ -63,7 +63,9 @@ unless MiniKraken::Core.constants(false).include? :Conj2
               else
                 Fiber.yield outcome1
               end
-              voc.clear if outcome1&.successful? && outcome2&.successful?
+              if outcome1.successful? && (outcome2&.successful? || outcome2.nil?)
+                voc.clear
+              end
             end
           end
 

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,6 +2,7 @@
 
 require 'singleton'
 require_relative 'duck_fiber'
+require_relative 'fail'
 require_relative 'goal'
 require_relative 'goal_relation'
 require_relative 'outcome'

data/lib/mini_kraken/core/equals.rb

@@ -31,9 +31,9 @@ unless MiniKraken::Core.constants(false).include? :Equals
           arg2_nil = arg2.nil?
           if arg1_nil || arg2_nil
             if arg1_nil && arg2_nil
-              result = Outcome.new(:"#s", anEnv)
+              result = Outcome.success(anEnv)
             else
-              result = Failure
+              result = Outcome.failure(anEnv)
             end
             return result
           end
@@ -46,6 +46,7 @@ unless MiniKraken::Core.constants(false).include? :Equals
 
         private
 
+
         # table: Unification
         # | arg1               | arg2               | Criterion                                 || Unification              |
         # | isa? Atomic        | isa? Atomic        | arg1.eq? arg2 is true                     || { "s", [] }              |
@@ -70,12 +71,12 @@ unless MiniKraken::Core.constants(false).include? :Equals
         # |                                         |   unification(arg1, arg2.value) => "u"    || { "u", [] }
         def do_unification(arg1, arg2, anEnv)
           # require 'debug'
-          return Outcome.new(:"#s", anEnv) if arg1.equal?(arg2)
+          return Outcome.success(anEnv) if arg1.equal?(arg2)
 
-          result = Outcome.new(:"#u", anEnv) # default case
+          result = Outcome.failure(anEnv) # default case
 
           if arg1.kind_of?(AtomicTerm)
-            result = BasicSuccess if arg1.eql?(arg2)
+            result = Outcome.success(anEnv) if arg1.eql?(arg2)
           elsif arg1.kind_of?(CompositeTerm)
             if arg2.kind_of?(CompositeTerm) # AtomicTerm is default case => fail
               result = unify_composite_terms(arg1, arg2, anEnv)
@@ -84,14 +85,14 @@ unless MiniKraken::Core.constants(false).include? :Equals
             arg1_freshness = arg1.freshness(anEnv)
             if arg2.kind_of?(AtomicTerm)
               if arg1_freshness.degree == :fresh
-                result = Outcome.new(:"#s", anEnv)
+                result = Outcome.success(anEnv)
                 arg1.associate(arg2, result)
               else
-                result = Outcome.new(:"#s", anEnv) if arg1.value(anEnv).eql?(arg2)
+                result = Outcome.success(anEnv) if arg1.value(anEnv).eql?(arg2)
               end
             elsif arg2.kind_of?(CompositeTerm)
               if arg1_freshness.degree == :fresh
-                result = Outcome.new(:"#s", anEnv)
+                result = Outcome.success(anEnv)
                 arg1.associate(arg2, result)
               else
                 # Ground case...
@@ -103,11 +104,14 @@ unless MiniKraken::Core.constants(false).include? :Equals
               when [false, false] # TODO: confirm this...
                 result = unification(arg1.value(anEnv), arg2.value(anEnv), anEnv)
               when [true, true]
-                result = Outcome.new(:"#s", anEnv)
+                result = Outcome.success(anEnv)
                 if arg1.var_name != arg2.var_name
                   arg1.associate(arg2, result)
                   arg2.associate(arg1, result)
                 end
+              when [true, false]
+                result = Outcome.success(anEnv)
+                arg1.associate(arg2, result)
               else
                 raise StandardError, "Unsupported freshness combination #{freshness}"
               end
@@ -123,7 +127,7 @@ unless MiniKraken::Core.constants(false).include? :Equals
         # @return [Freshness]
         def unify_composite_terms(arg1, arg2, anEnv)
           # require 'debug'
-          result = Outcome.new(:"#u", anEnv)
+          result = Outcome.failure(anEnv)
           children1 = arg1.children
           children2 = arg2.children
 
@@ -136,7 +140,7 @@ unless MiniKraken::Core.constants(false).include? :Equals
             end
             total_success = subresults.all?(&:successful?)
             if total_success
-              memo = Outcome.new(:"#s", anEnv)
+              memo = Outcome.success(anEnv)
               associations = subresults.reduce(memo) do |sub_total, outcome|
                 sub_total.merge(outcome)
                 sub_total
@@ -148,8 +152,8 @@ unless MiniKraken::Core.constants(false).include? :Equals
           result
         end
       end # class
-      
+
       Equals.instance.freeze
     end # module
   end # module
-end # unless
+end # unless

data/lib/mini_kraken/core/formal_arg.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module MiniKraken
+  module Core
+    # The generalization of any iem that can be
+    # passed as arugement to a goal.
+    class FormalArg
+      # @return [String]
+      attr_reader :name
+
+      def initialize(aName)
+        @name = validated_name(aName)
+      end
+
+      private
+
+      def validated_name(aName)
+        aName
+      end
+    end # class
+  end # module
+end # module