mini_kraken 0.2.02 → 0.2.03

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24222422e142dde60f6f5a3c92ca1b4967eb358f26d29a0d834f719d25fcab11
-  data.tar.gz: 855880806c2210763e6c77d442f8d0463c39b9bde81072ff91f65ca21a275998
+  metadata.gz: 6ae3703cbb0a7a854af490478227c915d7d9af72715be80cbd4e3c95cb7b2c3f
+  data.tar.gz: 27e04d428e1015f176fbafba7c047a0b12c28e9150161a7a5702190c8dd2e2e9
 SHA512:
-  metadata.gz: e7840d5f469d0924b5018a87ca9e349f7c17f81fb23c1b8001890f9b5ca752125fae2de08eb10af1e8fc430347dba3c1a635e25fe7c188196f93415ccaecbe95
-  data.tar.gz: 3a16f04afa89e31dbe572af6c26eeafb169143dc5d55419f4db1ee0c90b0268c60e0a1bee643a3bcdce769e3fd524dd6be37b8ad60211d814321f5b90e7f3350
+  metadata.gz: bd9cd60953f88610ce3a5009e0cad4099e1896643ad01f1c6616a4c20fb4495a71f5c5ed11efe98873362055bda2ec9d0ba4a1ce972844588cacab528ac5333d
+  data.tar.gz: 1c9d27a9fb7fa014f9789a159aff5309bd9c03ce810e994951373ee550698518683359815c4db43b9d95b00ba889670b824af18c1019af5442f2ca3b42c795ba

data/CHANGELOG.md

@@ -1,3 +1,21 @@
+## [0.2.03] - 2020-09-02
+- The DSL (Domain Specific Language) supports the `caro` relation & passes frames up to 2-8 from Chapter 2.
+
+### NEW
+- Class `ConsCellVisitor`. Its method `df_visitor` builds a Fiber that walks over a ConsCell (list/graph).
+- Method `Outcome#failure?`
+- Method `Outcome#prune!` for removing associations of transient variables.
+- Method `VariableRef#to_s` for providing a text representation of a variable reference
+- Method `Vocabulary#prune` for removing associations of transient variables.
+- Class `FreshEnvFactory` as its name implies, is used to build `FreshEnv` instances.
+
+### CHANGED
+- Method `Outcome#successful?` renamed to `Outcome#success?`
+
+### FIXED
+- Method `Equals#solver_for` now prunes associations of transient variables.
+- Method `Equals#unify_composite_terms` now copes with Conscell vs. VariableRef unification.
+
 ## [0.2.02] - 2020-08-08
 - The DSL (Domain Specific Language) now supports `conde` and passes all examples from Chapter 1.
 

data/README.md

@@ -23,14 +23,14 @@ ISBN: 9780262535519, (2018), MIT Press.
 - [X] conde
 - [X] conj2  
 - [X] disj2
-- [X] defrel   
+- [X] defrel  
+- [X] caro   
 
 ### TODO
 
 - [ ] Occurs check
 
-List-centric relations from Chapter 2
-- [ ] caro  
+List-centric relations from Chapter 2 
 - [ ] cdro  
 - [ ] conso  
 - [ ] nullo  

data/lib/mini_kraken.rb

@@ -12,4 +12,3 @@ module MiniKraken
 end
 
 # End of file
-

data/lib/mini_kraken/core/conde.rb

@@ -63,7 +63,7 @@ unless MiniKraken::Core.constants(false).include? :Conde
               break unless outcome
 
               outcome.parent = voc unless outcome.parent
-              if outcome.successful?
+              if outcome.success?
                 success = true
                 Fiber.yield outcome
                 outcome.clear

data/lib/mini_kraken/core/conj2.rb

@@ -43,14 +43,14 @@ unless MiniKraken::Core.constants(false).include? :Conj2
               break unless outcome1
 
               outcome1.parent = voc unless outcome1.parent
-              if outcome1.successful?
+              if outcome1.success?
                 f2 = g2.attain(outcome1)
                 loop do
                   outcome2 = f2.resume
                   break unless outcome2
 
                   outcome2.parent = voc unless outcome2.parent
-                  if outcome2.successful?
+                  if outcome2.success?
                     res = Outcome.new(:"#s", voc)
                     res.merge(outcome1)
                     res.merge(outcome2)
@@ -63,7 +63,7 @@ unless MiniKraken::Core.constants(false).include? :Conj2
               else
                 Fiber.yield outcome1
               end
-              if outcome1.successful? && (outcome2&.successful? || outcome2.nil?)
+              if outcome1.success? && (outcome2&.success? || outcome2.nil?)
                 voc.clear
               end
             end

data/lib/mini_kraken/core/cons_cell_visitor.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'set'
+require_relative 'cons_cell'
+
+module MiniKraken
+  module Core
+    # Factory class.
+    # Purpose: to create an enumerator specialized in the visit of cons cells.
+    class ConsCellVisitor
+      # Build a depth-first in-order expression tree visitor.
+      # The visitor is implemented as an Enumerator.
+      # The enumerator returns couples of the form: [:car or :cdr or :nil, visitee]
+      # [anExpr] the term to visit.
+      # @param aCell [ConsCell]
+      # @return [Fiber]
+      def self.df_visitor(aCell)
+        first = aCell	# The visit will start from the provided cons cell
+        visitor = Fiber.new do |skipping|
+          # Initialization part: will run once
+          visitees = Set.new # Keep track of the conscell already visited
+          visit_stack = first.nil? ? [] : [[:car, first]] # The LIFO queue of cells to visit
+
+          until visit_stack.empty?	# Traversal part (as a loop)
+            to_swap = false
+            side, cell = visit_stack.pop
+            next if visitees.include?(cell)
+
+            visitees << cell
+
+            skip_children = Fiber.yield [side, cell]
+            # require 'debug' if skip_children
+            next if skip_children || skipping
+
+            skipping = false
+            case cell.car
+              when ConsCell
+                visit_stack.push([:car, cell.car])
+                to_swap = true
+              else
+                Fiber.yield [:car, cell.car]
+            end
+
+            case cell.cdr
+              when ConsCell
+                if to_swap
+                  visit_stack.insert(-2, [:cdr, cell.cdr])
+                else
+                  visit_stack.push([:cdr, cell.cdr])
+                end
+              else
+                Fiber.yield [:cdr, cell.cdr]
+            end
+          end
+
+          # Send stop mark
+          Fiber.yield [:stop, nil]
+        end
+
+=begin
+        visitor = Enumerator.new do |requester|	# requester argument is a Yielder
+          # Initialization part: will run once
+          visitees = Set.new # Keep track of the conscell already visited
+          visit_stack = first.nil? ? [] : [[ :car, first ]] # The LIFO queue of cells to visit
+
+          until visit_stack.empty?	# Traversal part (as a loop)
+            to_swap = false
+            side, cell = visit_stack.pop()
+            next if visitees.include?(cell)
+
+            requester << [side, cell]
+            case cell.car
+              when ConsCell
+                visit_stack.push([:car, cell.car])
+                to_swap = true
+              else
+                requester << [:car, cell.car]
+            end
+
+            case cell.cdr
+              when ConsCell
+                if to_swap
+                  visit_stack.insert(-2, [:cdr, cell.cdr])
+                else
+                  visit_stack.push([:cdr, cell.cdr])
+                end
+              else
+                requester << [:cdr, cell.cdr]
+            end
+
+            visitees << cell
+          end
+
+          # Send stop mark
+          requester << [:stop, nil]
+        end
+=end
+        return visitor
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/def_relation.rb

@@ -15,6 +15,7 @@ module MiniKraken
 
       # @param aName [String] name of def relation
       # @param aGoalTemplate [GoalTemplate]
+      # @param theFormals [Array<FormalArg>]
       def initialize(aName, aGoalTemplate, theFormals, alternateName = nil)
         super(aName, alternateName)
         @formals = validated_formals(theFormals)
@@ -43,6 +44,8 @@ module MiniKraken
       end
 
       def validated_goal_template(aGoalTemplate)
+        raise StandardError unless aGoalTemplate
+
         aGoalTemplate
       end
     end # class

data/lib/mini_kraken/core/disj2.rb

@@ -44,7 +44,7 @@ unless MiniKraken::Core.constants(false).include? :Disj2
               break unless outcome1
 
               outcome1.parent = voc unless outcome1.parent
-              if outcome1.successful?
+              if outcome1.success?
                 Fiber.yield outcome1
                 outcome1.clear
               end
@@ -55,7 +55,7 @@ unless MiniKraken::Core.constants(false).include? :Disj2
               break unless outcome2
 
               outcome2.parent = voc unless outcome2.parent
-              if outcome2.successful?
+              if outcome2.success?
                 Fiber.yield outcome2
                 outcome2.clear
               end

data/lib/mini_kraken/core/environment.rb

@@ -57,7 +57,7 @@ module MiniKraken
       # Roll up associations from descendent outcome object
       # @param descendent [Outcome]
       def do_propagate(descendent)
-        return unless descendent.successful?
+        return unless descendent.success?
 
         vars.each_key do |var_name|
           # assocs = descendent[var_name]

data/lib/mini_kraken/core/equals.rb

@@ -2,7 +2,7 @@
 
 require 'singleton'
 require_relative 'binary_relation'
-# require_relative 'any_value'
+require_relative 'cons_cell_visitor'
 require_relative 'duck_fiber'
 require_relative 'variable'
 require_relative 'variable_ref'
@@ -23,7 +23,10 @@ unless MiniKraken::Core.constants(false).include? :Equals
         # @return [Fiber<Outcome>] A Fiber(-like) instance that yields Outcomes
         def solver_for(actuals, anEnv)
           arg1, arg2 = *actuals
-          DuckFiber.new(:custom) { unification(arg1, arg2, anEnv) }
+          DuckFiber.new(:custom) do
+            outcome = unification(arg1, arg2, anEnv)
+            outcome.prune!
+          end
         end
 
         def unification(arg1, arg2, anEnv)
@@ -93,7 +96,10 @@ unless MiniKraken::Core.constants(false).include? :Equals
                 arg1.associate(arg2, result)
               else
                 # Ground case...
-                result = unify_composite_terms(arg1_freshness.associated, arg2, anEnv)
+                arg1_associated = arg1_freshness.associated
+                unless arg1_associated.kind_of?(AtomicTerm)
+                  result = unify_composite_terms(arg1_associated, arg2, anEnv)
+                end
               end
             elsif arg2.kind_of?(VariableRef)
               freshness = [arg1.fresh?(anEnv), arg2.fresh?(anEnv)]
@@ -121,33 +127,64 @@ unless MiniKraken::Core.constants(false).include? :Equals
           result
         end
 
-        # @return [Freshness]
+        # @param arg1 [ConsCell]
+        # @param arg2 [ConsCell]
+        # @return [Outcome]
         def unify_composite_terms(arg1, arg2, anEnv)
           # require 'debug'
-          result = Outcome.failure(anEnv)
-          children1 = arg1.children
-          children2 = arg2.children
-
-          if children1.size == children2.size
-            i = 0
-            subresults = children1.map do |child1|
-              child2 = children2[i]
-              i += 1
-              unification(child1, child2, anEnv)
-            end
-            total_success = subresults.all?(&:successful?)
-            if total_success
-              memo = Outcome.success(anEnv)
-              subresults.reduce(memo) do |sub_total, outcome|
-                sub_total.merge(outcome)
-                sub_total
+          result = Outcome.success(anEnv)
+          # We'll do parallel iteration
+          visitor1 = ConsCellVisitor.df_visitor(arg1)
+          visitor2 = ConsCellVisitor.df_visitor(arg2)
+          skip_children1 = false
+          skip_children2 = false
+
+          loop do
+            side1, cell1 = visitor1.resume(skip_children1)
+            side2, cell2 = visitor2.resume(skip_children2)
+            if side1 != side2
+              result = Outcome.failure(anEnv)
+            elsif side1 == :stop
+              break
+            else
+              case [cell1.class, cell2.class] # nil, AtomicTerm, ConsCell, VariableRef
+                when [ConsCell, ConsCell]
+                  skip_children1 = false
+                  skip_children2 = false
+                when [ConsCell, VariableRef]
+                  skip_children1 = true
+                  skip_children2 = false
+                  sub_result = unification(cell1, cell2, anEnv)
+                  result = merge_results(result, sub_result)
+                when [VariableRef, ConsCell]
+                  skip_children1 = false
+                  skip_children2 = true
+                  sub_result = do_unification(cell1, cell2, anEnv)
+                  result = merge_results(result, sub_result)
+              else
+                skip_children1 = false
+                skip_children2 = false
+                sub_result = unification(cell1, cell2, anEnv)
+                result = merge_results(result, sub_result)
               end
-              result = memo
             end
+
+            break if result.failure?
           end
 
           result
         end
+
+        def merge_results(result1, result2)
+          raise StandardError if result2.kind_of?(Hash)
+
+          if result2.success?
+            result1.merge(result2)
+            result1
+          else
+            result2
+          end
+        end
       end # class
 
       Equals.instance.freeze

data/lib/mini_kraken/core/goal_template.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
 require_relative 'base_arg'
+require_relative 'cons_cell_visitor'
 
 module MiniKraken
   module Core
     # A meta-goal that is parametrized with generic formal arguments.
     # The individual goals are instantiated when the formal arguments
-    # are bound to goal arguments
+    # are bound to goal arguments.
     class GoalTemplate < BaseArg
       # @return [Array<BaseArg>] Arguments of goal template.
       attr_reader :args
@@ -14,13 +15,16 @@ module MiniKraken
       # @return [Relation] Main relation for the goal template
       attr_reader :relation
 
+      # @param aRelation [Core::Rzlation] the relation
+      # @param theArgs [Array<Core::BaseArg>] Arguments of goal template.
       def initialize(aRelation, theArgs)
         super()
         @relation = validated_relation(aRelation)
         @args = validated_args(theArgs)
-        freeze
+        args.freeze
       end
 
+      # Factory method: Create a goal object.
       # @param formals [Array<FormalArg>] Array of formal arguments
       # @param actuals [Array<GoalArg>] Array of actual arguments
       # @return [Goal] instantiate a goal object given the actuals and environment
@@ -50,6 +54,9 @@ module MiniKraken
             goal_args << formals2actuals[arg.name]
           elsif arg.kind_of?(GoalTemplate)
             goal_args << arg.send(:do_instantiate, formals2actuals)
+          elsif arg.kind_of?(ConsCell)
+            # if list contains a formal_ref it must be replaced by the actual
+            goal_args << transform(arg, formals2actuals)
           else
             goal_args << arg
           end
@@ -57,6 +64,39 @@ module MiniKraken
 
         Goal.new(relation, goal_args)
       end
+
+      private
+
+      def transform(aConsCell, formals2actuals)
+        return aConsCell if aConsCell.null?
+
+        member = { car: :@car, cdr: :@cdr }
+        visitor = ConsCellVisitor.df_visitor(aConsCell)
+        side, cell = visitor.resume
+        result = ConsCell.new(nil, nil)
+        node = result
+
+        loop do
+          side, cell = visitor.resume
+          break if side == :stop
+
+          converted = nil
+          case cell
+            when FormalRef
+              converted = formals2actuals[cell.name]
+            when ConsCell
+              converted = ConsCell.new(nil, nil)
+            when GoalTemplate
+              converted = cell.send(:do_instantiate, formals2actuals)
+            else
+              converted = cell
+          end
+          node.instance_variable_set(member[side], converted)
+          node = converted if converted.kind_of?(ConsCell)
+        end
+
+        result
+      end
     end # class
   end # module
 end # module

data/lib/mini_kraken/core/k_boolean.rb

@@ -11,7 +11,7 @@ module MiniKraken
       def initialize(aValue)
         super(validated_value(aValue))
       end
-      
+
       def to_s
         value.to_s
       end