mini_kraken 0.2.04 → 0.3.00

data/lib/mini_kraken/core/outcome.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'vocabulary'
-
-unless MiniKraken::Core.constants(false).include? :Outcome
-  module MiniKraken
-    module Core
-      class Outcome
-        include Vocabulary # Use mix-in module
-
-        # @return [Symbol] One of: :"#s" (success), :"#u" (failure)
-        attr_reader :resultant
-
-        def initialize(aResult, aParent = nil)
-          init_vocabulary(aParent)
-          @resultant = aResult
-        end
-
-        def self.failure(aParent = nil)
-          new(:"#u", aParent)
-        end
-
-        def self.success(aParent = nil)
-          new(:"#s", aParent)
-        end
-
-        def failure?
-          resultant != :"#s"
-        end
-
-        def success?
-          resultant == :"#s"
-        end
-
-        def ==(other)
-          are_equal = false
-
-          if resultant == other.resultant && parent == other.parent &&
-             associations == other.associations
-            are_equal = true
-          end
-
-          are_equal
-        end
-
-        # Remove associations of variables of this environment, if
-        # persistence flag is set to false.
-        def prune!
-          parent.prune(self)
-        end
-
-        protected
-
-        def introspect
-          ", @resultant=#{resultant}"
-        end
-      end # class
-
-      Failure = Outcome.new(:"#u")
-      BasicSuccess = Outcome.new(:"#s")
-    end # module
-  end # module
-end # defined

data/lib/mini_kraken/core/tap.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'singleton'
-require_relative 'duck_fiber'
-require_relative 'goal'
-require_relative 'goal_relation'
-require_relative 'outcome'
-
-module MiniKraken
-  module Core
-    class Tap < GoalRelation
-      include Singleton
-
-      def initialize
-        super('tap', nil)
-      end
-
-      def arity
-        1
-      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)
-        DuckFiber.new(:custom) do
-          outcome = tap(args.first, anEnv)
-          # outcome.prune!
-        end
-      end
-
-      def tap(aGoal, anEnv)
-        require 'debug'
-        f1 = aGoal.attain(anEnv)
-        outcome1 = f1.resume
-        # key = outcome1.associations.keys.first
-        # outcome1.associations['x'] = outcome1.associations[key]
-        # outcome1.associations.delete(key)
-        outcome1
-      end
-    end # class
-
-    Tap.instance.freeze
-  end # module
-end # module

data/lib/mini_kraken/core/vocabulary.rb

@@ -1,446 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-require_relative 'association'
-require_relative 'association_walker'
-
-module MiniKraken
-  module Core
-    module Vocabulary
-      # @return [Environment] Parent environment to this one.
-      attr_accessor :parent
-
-      # @return [Hash] Pairs of the kind {String => Array[Association]}
-      attr_reader :associations
-
-      # @return [Hash] Pairs of the kind {String => Integer}
-      attr_reader :rankings
-
-      # @param aParent [Environment, NilClass] Parent environment to this one.
-      def init_vocabulary(aParent = nil)
-        @parent = validated_parent(aParent)
-        @associations = {}
-        @rankings = {} unless aParent
-      end
-
-      # Return a Enumerator object that can iterate over this vocabulary and
-      # all its direct and indirect parent(s).
-      # @return [Enumerator<Vocabulary, NilClass>]
-      def ancestor_walker
-        unless @ancestors # Not yet in cache?...
-          @ancestors = []
-          relative = self
-          while relative
-            @ancestors << relative
-            relative = relative.parent
-          end
-          @ancestors << nil # nil marks end of iteration...
-        end
-
-        @ancestors.to_enum
-      end
-
-      def clear_rankings
-        walker = ancestor_walker
-        orphan = nil
-        loop do
-          orphan_temp = walker.next
-          break unless orphan_temp
-
-          orphan = orphan_temp
-        end
-
-        orphan.rankings&.clear
-      end
-
-      # @param aName [String]
-      # @param alternate_names [Array<String>]
-      def get_rank(aName, alternate_names = [])
-        walker = ancestor_walker
-        orphan = nil
-        loop do
-          orphan_temp = walker.next
-          break unless orphan_temp
-
-          orphan = orphan_temp
-        end
-
-        raise StandardError unless orphan
-
-        rank = nil
-        if orphan.rankings.include?(aName)
-          rank = orphan.rankings[aName]
-        else
-          other = alternate_names.find do |a_name|
-            rank = orphan.rankings.include?(a_name)
-          end
-          if other
-            rank = get_rank(other)
-          else
-            rank = orphan.rankings.keys.size
-            orphan.rankings[aName] = rank
-          end
-        end
-
-        rank
-      end
-
-      # Record an association between a variable with given user-defined name
-      # and a term.
-      # @param aName [String, Variable] A user-defined variable name
-      # @param aTerm [Term] A term to associate with the variable
-      def add_assoc(aName, aTerm)
-        name = aName.respond_to?(:name) ? aName.name : aName
-
-        var = name2var(name)
-        unless var
-          err_msg = "Unknown variable '#{name}'."
-          raise StandardError, err_msg
-        end
-        siblings = detect_fuse(var, aTerm)
-        if siblings.empty?
-          anAssociation = Association.new(var.i_name, aTerm)
-          do_add_assocs([anAssociation]).first
-        else
-          fuse_vars(siblings << var)
-        end
-      end
-
-      # Handler for the event: an outcome has been produced.
-      # Can be overridden in other to propagate associations from child
-      # @param _descendent [Outcome]
-      def propagate(_descendent)
-        # Do nothing...
-      end
-
-      # Remove all the associations of this vocabulary
-      def clear
-        associations.clear
-      end
-
-      # @param aVarName [String] A user-defined variable name
-      # @param other [Vocabulary]
-      def move_assocs(aVarName, other)
-        i_name = to_internal(aVarName)
-        assocs = other.associations[i_name]
-        if assocs
-          do_add_assocs(assocs)
-          other.associations.delete(i_name)
-        end
-      end
-
-      # Merge the associations from another vocabulary-like object.
-      # @param another [Vocabulary]
-      def merge(another)
-        another.associations.each_value { |assocs| do_add_assocs(assocs) }
-      end
-
-      # Check that the provided variable must be fused with the argument.
-      # @return [Array<Variable>]
-      def detect_fuse(aVariable, aTerm)
-        return [] unless aTerm.kind_of?(LogVarRef)
-
-        assocs = self[aTerm.var_name]
-        # Simplified implementation: cope with binary cycles only...
-        # TODO: Extend to n-ary (n > 2) cycles
-        assoc_refs = assocs.select { |a| a.value.kind_of?(LogVarRef) }
-        return [] if assoc_refs.empty? # No relevant association...
-
-        visitees = Set.new
-        to_fuse = []
-        to_visit = assoc_refs
-        loop do
-          assc = to_visit.shift
-          next if visitees.include?(assc)
-
-          visitees.add(assc)
-          ref = assc.value
-          if ref.var_name == aVariable.name
-            to_fuse << assc.i_name unless assc.i_name == aVariable.i_name
-          end
-          other_assocs = self[ref.var_name]
-          other_assoc_refs = other_assocs.select { |a| a.value.kind_of?(LogVarRef) }
-          other_assoc_refs.each do |a|
-            to_visit << a unless visitess.include?(a)
-          end
-
-
-          break if to_visit.empty?
-        end
-
-        to_fuse.map { |i_name| i_name2var(i_name) }
-      end
-
-      # Fuse the given variables:
-      # Collect all their associations
-      # Put them under a new internal name
-      # Remove all entries from old internal names
-      # For all fused variables, change internal names
-      # @param theVars [Array<Variable>]
-      def fuse_vars(theVars)
-        new_i_name = Object.new.object_id.to_s
-        fused_vars = theVars.dup
-        fused_vars.each do |a_var|
-          old_i_name = a_var.i_name
-          old_names = fused_vars.map(&:name)
-          walker = ancestor_walker
-
-          loop do
-            voc = walker.next
-            break unless voc
-
-            if voc.associations.include?(old_i_name)
-              assocs = voc.associations[old_i_name]
-              keep_assocs = assocs.reject do |assc|
-                assc.value.kind_of?(LogVarRef) && old_names.include?(assc.value.var_name)
-              end
-              unless keep_assocs.empty?
-                keep_assocs.each { |assc| assc.i_name = new_i_name }
-                if voc.associations.include?(new_i_name)
-                  voc.associations[new_i_name].concat(keep_assocs)
-                else
-                  voc.associations[new_i_name] = keep_assocs
-                end
-              end
-              voc.associations.delete(old_i_name)
-            end
-            next unless voc.respond_to?(:vars) && voc.vars.include?(a_var.name)
-
-            user_names = voc.ivars[old_i_name]
-            unseen = user_names.reject { |nm| old_names.include?(nm) }
-            unseen.each do |usr_name|
-              new_var = name2var(usr_name)
-              fused_vars << new_var
-            end
-            unless voc.ivars.include?(new_i_name)
-              voc.ivars[new_i_name] = user_names
-            else
-              voc.ivars[new_i_name].merge(user_names)
-            end
-            voc.ivars.delete(old_i_name)
-            break
-          end
-          a_var.i_name = new_i_name
-        end
-      end
-
-      # @param var [Variable, LogVarRef] the variable to check.
-      # @return [Boolean]
-      def fresh?(var)
-        ground_term = ground_value(var)
-        ground_term.nil? ? true : false
-      end
-
-      # @param var [Variable, LogVarRef] variable for which the value to retrieve
-      # @return [Term, NilClass]
-      def ground_value(var)
-        name = var.respond_to?(:var_name) ? var.var_name : var.name
-
-        walker = AssociationWalker.new
-        walker.find_ground(name, self)
-      end
-
-      # @param val [CompositeTerm] the composite term to check.
-      # @return [Boolean]
-      def fresh_value?(val)
-        walker = AssociationWalker.new
-        ground_term = walker.walk_value(val, self)
-        ground_term.nil? ? true : false
-      end
-
-      # A composite term is fresh when all its members are nil or all non-nil members
-      # are all fresh
-      # A composite term is bound when it is not fresh and not ground
-      # A composite term is a ground term when all its non-nil members are ground.
-      # @param aComposite [CompositeTerm]
-      # @return [Freshness]
-      def freshness_composite(aComposite)
-        walker = AssociationWalker.new
-        walker.freshness_composite(aComposite)
-      end
-
-      # Determine whether the reference points to a fresh, bound or ground term.
-      # @param aVariableRef [LogVarRef]
-      # @return [Freshness]
-      def freshness_ref(aVariableRef)
-        walker = AssociationWalker.new
-        walker.determine_freshness(aVariableRef, self)
-      end
-
-      # @param aVariableRef [LogVarRef]
-      # @return [Term, NilClass]
-      def quote_ref(aVariableRef)
-        walker = AssociationWalker.new
-        walker.quote_term(aVariableRef, self)
-      end
-
-      # Return the variable with given user-defined variable name.
-      # @param aName [String] User-defined variable name
-      def name2var(aName)
-        var = nil
-        walker = ancestor_walker
-
-        loop do
-          voc = walker.next
-          if voc
-            next unless voc.respond_to?(:vars) && voc.vars.include?(aName)
-
-            var = voc.vars[aName]
-          end
-
-          break
-        end
-
-        var
-      end
-
-      # Return the variable with given internal variable name.
-      # @param i_name [String] internal variable name
-      # @return [Variable]
-      def i_name2var(i_name)
-        var = nil
-        voc = nil
-        walker = ancestor_walker
-
-        loop do
-          voc = walker.next
-          if voc
-            next unless voc.respond_to?(:ivars) && voc.ivars.include?(i_name)
-
-            var_name = voc.ivars[i_name].first # TODO: what if multiple vars?
-            var = voc.vars[var_name]
-          end
-
-          break
-        end
-
-        raise StandardError, 'Nil variable object' if var.nil?
-
-        var
-      end
-
-      # Return the internal name to corresponding to a given user-defined
-      #   variable name.
-      # @param aName [String] User-defined variable name
-      def to_internal(aName)
-        var = name2var(aName)
-        var ? var.i_name : nil
-      end
-
-      # Return the internal names fused with given user-defined
-      #   variable name.
-      # @param aName [String] User-defined variable name
-      def names_fused(aName)
-        # require 'debug'
-        var = name2var(aName)
-        return [] unless var&.fused?
-
-        i_name = var.i_name
-        names = []
-        walker = ancestor_walker
-
-        loop do
-          voc = walker.next
-          break unless voc
-          next unless voc.respond_to?(:ivars)
-
-          if voc.ivars.include?(i_name)
-            fused = voc.ivars[i_name]
-            names.concat(fused.to_a)
-          end
-        end
-
-        names.uniq!
-        names.reject { |nm| nm == aName }
-      end
-
-      # Retrieve all the associations for a given variable
-      # @param aVariable [Variable]
-      # @return [Array<Association>]
-      def assocs4var(aVariable)
-        i_name = aVariable.i_name
-        assocs = []
-        walker = ancestor_walker
-
-        loop do
-          voc = walker.next
-          break unless voc
-          next unless voc.associations.include?(i_name)
-
-          assocs.concat(voc.associations[i_name])
-        end
-
-        assocs
-      end
-
-      # @param aName [String] User-defined variable name
-      # @return [Array<Association>]
-      def [](aName)
-        iname = to_internal(aName)
-        return [] unless iname
-
-        assoc_arr = associations[iname]
-        assoc_arr = [] if assoc_arr.nil?
-
-        # TODO: Optimize
-        assoc_arr.concat(parent[aName]) if parent
-        assoc_arr
-      end
-
-      # Check that a variable with given name is defined in this vocabulary
-      # or one of its ancestor.
-      # @param aVarName [String] A user-defined variable name.
-      # @return [Boolean]
-      def include?(aVarName)
-        name2var(aVarName) ? true : false
-      end
-
-      def prune(anOutcome)
-        anOutcome # Don't touch outcome
-      end
-
-      def inspect
-        result = +"#<#{self.class.name}:#{object_id.to_s(16)} @parent="
-        if parent
-          result << "#<#{parent.class.name}:#{parent.object_id.to_s(16)}>"
-        else
-          result << 'nil'
-        end
-        result << introspect
-        result << '>'
-        result
-      end
-
-      protected
-
-      def validated_parent(aParent)
-        if aParent
-          unless aParent.kind_of?(Vocabulary)
-            raise StandardError, "Invalid parent type #{aParent.class}"
-          end
-        end
-
-        aParent
-      end
-
-      # @param theAssociations [Array<Association>]
-      def do_add_assocs(theAssociations)
-        theAssociations.each do |assc|
-          i_name = assc.i_name
-          found_assocs = associations[i_name]
-          if found_assocs
-            found_assocs << assc
-          else
-            associations[i_name] = [assc]
-          end
-
-          assc
-        end
-      end
-
-      def introspect
-        ''
-      end
-    end # class
-  end # module
-end # module