mini_kraken 0.2.02 → 0.3.02

data/lib/mini_kraken/core/formal_arg.rb

@@ -1,22 +0,0 @@
-# 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

data/lib/mini_kraken/core/formal_ref.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_arg'
-
-module MiniKraken
-  module Core
-    # A formal reference represents the occurrence of a formal argument name in a
-    # goal template argument list.
-    class FormalRef < BaseArg
-      # @return [String] The name of a formal argument.
-      attr_reader :name
-
-      def initialize(aName)
-        super()
-        @name = validated_name(aName)
-      end
-
-      private
-
-      def validated_name(aName)
-        aName
-      end
-    end # class
-  end # module
-end # module

data/lib/mini_kraken/core/freshness.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module MiniKraken
-  module Core
-    # Freshness: fresh, bound, ground
-    # fresh: no association at all
-    # bound: associated to something that is itself not ground.
-    # ground: associated to something that is either an atomic, a composite with ground members,
-    #   a variable reference to something that is itself ground.
-    # RS fresh == fresh or bound
-    # RS not fresh == ground
-    # RS result == fresh => any or bound => expr(any)
-    Freshness = Struct.new(:degree, :associated) do
-      def initialize(aDegree, anAssociated)
-        super(aDegree, valid_associated(anAssociated))
-      end
-
-      def fresh?
-        degree == :fresh
-      end
-
-      def bound?
-        degree == :bound
-      end
-
-      def ground?
-        degree == :ground
-      end
-
-      # Does this instance represent something fresh according to
-      # "Reasoned Schemer" book ?
-      def rs_fresh?
-        degree != ground
-      end
-
-      private
-
-      def valid_associated(anAssociated)
-        raise StandardError, 'Wrong argument' if anAssociated.kind_of?(self.class)
-
-        anAssociated
-      end
-    end # struct
-  end # module
-end # module

data/lib/mini_kraken/core/goal_arg.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_arg'
-
-module MiniKraken
-  module Core
-    # The generalization of any item that can be
-    # passed as arugement to a goal object
-    class GoalArg < BaseArg
-    end # class
-  end # module
-end # module

data/lib/mini_kraken/core/goal_template.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_arg'
-
-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
-    class GoalTemplate < BaseArg
-      # @return [Array<BaseArg>] Arguments of goal template.
-      attr_reader :args
-
-      # @return [Relation] Main relation for the goal template
-      attr_reader :relation
-
-      def initialize(aRelation, theArgs)
-        super()
-        @relation = validated_relation(aRelation)
-        @args = validated_args(theArgs)
-        freeze
-      end
-
-      # @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
-      def instantiate(formals, actuals)
-        formals2actuals = {}
-        formals.each_with_index do |frml, i|
-          formals2actuals[frml.name] = actuals[i]
-        end
-
-        do_instantiate(formals2actuals)
-      end
-
-      private
-
-      def validated_relation(aRelation)
-        aRelation
-      end
-
-      def validated_args(theArgs)
-        theArgs
-      end
-
-      def do_instantiate(formals2actuals)
-        goal_args = []
-        args.each do |arg|
-          if arg.kind_of?(FormalRef)
-            goal_args << formals2actuals[arg.name]
-          elsif arg.kind_of?(GoalTemplate)
-            goal_args << arg.send(:do_instantiate, formals2actuals)
-          else
-            goal_args << arg
-          end
-        end
-
-        Goal.new(relation, goal_args)
-      end
-    end # class
-  end # module
-end # module

data/lib/mini_kraken/core/k_boolean.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'atomic_term'
-
-module MiniKraken
-  module Core
-    # A specialized atomic term that represents an boolean (true/false) value.
-    # in MiniKraken
-    class KBoolean < AtomicTerm
-      # @param aValue [Boolean, Symbol] Ruby representation of boolean value
-      def initialize(aValue)
-        super(validated_value(aValue))
-      end
-      
-      def to_s
-        value.to_s
-      end
-
-      private
-
-      def validated_value(aValue)
-        case aValue
-          when true, false
-            aValue
-          when :"#t", '#t'
-            true
-          when :"#f", '#f'
-            false
-          else
-            raise StandardError, "Invalid boolean literal '#{aValue}'"
-        end
-      end
-    end # class
-  end # module
-end # module

data/lib/mini_kraken/core/outcome.rb

@@ -1,53 +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 successful?
-          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
-
-        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/variable.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'designation'
-require_relative 'any_value'
-require_relative 'vocabulary'
-
-module MiniKraken
-  module Core
-    # Representation of a MiniKraken variable.
-    # It is a named slot that can be associated with one value.
-    class Variable
-      include Designation # Mixin: Acquire name attribute
-
-      # @return [String] Internal variable name used by MiniKraken
-      attr_accessor :i_name
-
-      # @param aName [String] The name of the variable
-      def initialize(aName)
-        init_designation(aName)
-        @i_name = name.dup
-      end
-
-      def fused?
-        name != i_name
-      end
-
-      def quote(env)
-        raise StandardError, "class #{env}" unless env.kind_of?(Vocabulary)
-
-        val = env.quote_ref(self)
-        unless val
-          result = AnyValue.new(name, env, env.names_fused(name))
-        else
-          result = val
-        end
-
-        result
-      end
-    end # class
-  end # module
-end # module

data/lib/mini_kraken/core/variable_ref.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'term'
-require_relative 'any_value'
-
-module MiniKraken
-  module Core
-    # A variable reference represents the occurrence of a variable (name) in a
-    # MiniKraken term.
-    class VariableRef < Term
-      include Designation # Mixin: Acquire name attribute
-      alias var_name name
-
-      # @param aName [String] The name of the variable
-      def initialize(aName)
-        super()
-        init_designation(aName)
-      end
-
-      # @param aValue [Term]
-      # @param env [Environment]
-      def associate(aValue, env)
-        env.add_assoc(var_name, aValue)
-      end
-
-      # @param env [Environment]
-      # @return [Array<Term>]
-      def values(env)
-        env[var_name].map(&:value)
-      end
-
-      # @param env [Environment]
-      # @return [Term, NilClass]
-      def value(env)
-        freshness = env.freshness_ref(self)
-        freshness.associated
-      end
-
-      # @param env [Environment]
-      def quote(env)
-        val = env.quote_ref(self)
-        val.nil? ? AnyValue.new(var_name, env, names_fused(env)) : val
-      end
-
-      # param another [VariableRef]
-      # @param env [Environment]
-      # @return [Boolean]
-      def fused_with?(another, env)
-        my_var = env.name2var(var_name)
-        return false unless my_var.fused?
-
-        other_var = env.name2var(another.var_name)
-        return my_var.i_name == other_var.i_name
-      end
-
-      def names_fused(env)
-        env.names_fused(var_name)
-      end
-
-      # param another [VariableRef]
-      # @param env [Environment]
-      # @return [Boolean]
-      def different_from?(another, env)
-        !fused_with?(another, env)
-      end
-
-      private
-
-      def valid_name(aName)
-        if aName.empty?
-          raise StandardError, 'Variable name may not be empty.'
-        end
-
-        aName
-      end
-    end # class
-  end # module
-end # module

data/lib/mini_kraken/core/vocabulary.rb

@@ -1,442 +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?(VariableRef)
-
-        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?(VariableRef) }
-        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?(VariableRef) }
-          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, that is:
-      # 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?(VariableRef) && 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, VariableRef] the variable to check.
-      # @return [Boolean]
-      def fresh?(var)
-        ground_term = ground_value(var)
-        ground_term.nil? ? true : false
-      end
-
-      # @param var [Variable, VariableRef] 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 [VariableRef]
-      # @return [Freshness]
-      def freshness_ref(aVariableRef)
-        walker = AssociationWalker.new
-        walker.determine_freshness(aVariableRef, self)
-      end
-
-      # @param aVariableRef [VariableRef]
-      # @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 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