mini_kraken 0.1.12 → 0.2.03

data/lib/mini_kraken.rb

@@ -1,8 +1,14 @@
 # frozen_string_literal: true
 
-require 'mini_kraken/version'
+# This file acts as a jumping-off point for loading dependencies expected
+# for a MiniKraken client.
+
+require_relative './mini_kraken/version'
+require_relative './mini_kraken/glue/dsl'
 
 module MiniKraken
   class Error < StandardError; end
   # Your code goes here...
 end
+
+# End of file

data/lib/mini_kraken/core/any_value.rb

@@ -12,7 +12,11 @@ module MiniKraken
       end
 
       def ==(other)
-        rank == other.rank
+        if other.is_a?(AnyValue)
+          rank == other.rank
+        elsif other.id2name =~ /_\d+/
+          rank == other.id2name.sub(/_/, '').to_i
+        end
       end
 
       # Use same text representation as in Reasoned Schemer.

data/lib/mini_kraken/core/atomic_term.rb

@@ -13,6 +13,7 @@ module MiniKraken
 
       # @param aValue [Object] Ruby representation of MiniKraken data value
       def initialize(aValue)
+        super()
         @value = aValue
         @value.freeze
       end

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.rb

@@ -10,8 +10,13 @@ unless MiniKraken::Core.constants(false).include? :ConsCell
         attr_reader :cdr
 
         def initialize(obj1, obj2 = nil)
+          super()
           @car = obj1
-          @cdr = obj2
+          if obj2.kind_of?(ConsCell) && obj2.null?
+            @cdr = nil
+          else
+            @cdr = obj2
+          end
         end
 
         def children
@@ -42,9 +47,32 @@ unless MiniKraken::Core.constants(false).include? :ConsCell
           ConsCell.new(new_car, new_cdr)
         end
 
+        # Use the list notation from Lisp as a text representation.
+        def to_s
+          return '()' if null?
+
+          "(#{pair_to_s})"
+        end
+
         def append(another)
           @cdr = another
         end
+
+        protected
+
+        def pair_to_s
+          result = +car.to_s
+          if cdr
+            result << ' '
+            if cdr.kind_of?(ConsCell)
+              result << cdr.pair_to_s
+            else
+              result << ". #{cdr}"
+            end
+          end
+
+          result
+        end
       end # class
 
       # Constant representing the null (empty) list.

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,10 +15,12 @@ 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)
         @goal_template = validated_goal_template(aGoalTemplate)
+        freeze
       end
 
       # Number of arguments for the relation.
@@ -42,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,10 +57,10 @@ 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]
+          # assocs = descendent[var_name]
           move_assocs(var_name, descendent)
         end
       end

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)
@@ -38,10 +41,7 @@ unless MiniKraken::Core.constants(false).include? :Equals
             return result
           end
           new_arg1, new_arg2 = commute_cond(arg1, arg2, anEnv)
-          result = do_unification(new_arg1, new_arg2, anEnv)
-          # anEnv.merge(result) if result.successful? && !result.association.empty?
-
-          result
+          do_unification(new_arg1, new_arg2, anEnv)
         end
 
         private
@@ -96,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)]
@@ -124,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)
-              associations = 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/formal_ref.rb

@@ -7,10 +7,11 @@ module MiniKraken
     # A formal reference represents the occurrence of a formal argument name in a
     # goal template argument list.
     class FormalRef < BaseArg
-      # @return [String]
+      # @return [String] The name of a formal argument.
       attr_reader :name
 
       def initialize(aName)
+        super()
         @name = validated_name(aName)
       end
 

data/lib/mini_kraken/core/goal.rb

@@ -16,6 +16,7 @@ module MiniKraken
       # @param aRelation [Relation] The relation corresponding to this goal
       # @param args [Array<Term>] The actual aguments of the goal
       def initialize(aRelation, args)
+        super()
         @relation = aRelation
         @actuals = validated_actuals(args)
       end
@@ -35,14 +36,15 @@ module MiniKraken
           raise StandardError, err_msg
         end
 
-        prefix = 'Invalid goal argument '
+        prefix = 'Invalid goal argument'
         args.each do |actual|
           if actual.kind_of?(GoalArg) || actual.kind_of?(Environment)
             next
           elsif actual.kind_of?(Array)
             validated_actuals(actual)
           else
-            raise StandardError, prefix + actual.to_s
+            actual_display = actual.nil? ? 'nil' : actual.to_s
+            raise StandardError, "#{prefix} '#{actual_display}'"
           end
         end
 

data/lib/mini_kraken/core/goal_template.rb

@@ -1,24 +1,30 @@
 # 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.
+      # @return [Array<BaseArg>] Arguments of goal template.
       attr_reader :args
 
       # @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)
+        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
@@ -48,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
@@ -55,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