mini_kraken 0.2.04 → 0.3.00

data/lib/mini_kraken/core/environment.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-require_relative 'vocabulary'
-
-module MiniKraken
-  module Core
-    class Environment
-      include Vocabulary # Use mix-in module
-
-      # Mapping from user-defined name to Variable instance
-      # @return [Hash] Pairs of the kind {String => Variable}
-      attr_reader :vars
-
-      # Mapping from internal name to user-defined name(s)
-      # @return [Hash] Pairs of the kind {String => Set<String>}
-      attr_reader :ivars
-
-      # @param aParent [Environment, NilClass] Parent environment to this one.
-      def initialize(aParent = nil)
-        init_vocabulary(aParent)
-        @vars = {}
-        @ivars = {}
-      end
-
-      # @param aVariable [Variable]
-      def add_var(aVariable)
-        name = aVariable.name
-        if vars.include?(name)
-          err_msg = "Variable with name '#{name}' already exists."
-          raise StandardError, err_msg
-        end
-        vars[name] = aVariable
-        i_name = aVariable.i_name
-        if ivars.include?(i_name)
-          set = ivars[i_name]
-          set.add(name)
-        else
-          ivars[i_name] = Set.new([i_name])
-        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)
-        # Rollout associations from hierarchy
-        walker = descendent.ancestor_walker
-        begin
-          env = walker.next
-          break if env.nil?
-
-          env.do_propagate(descendent) if env.kind_of?(Environment)
-        end until env.equal?(self)
-      end
-
-      # Roll up associations from descendent outcome object
-      # @param descendent [Outcome]
-      def do_propagate(descendent)
-        return unless descendent.success?
-
-        vars.each_key do |var_name|
-          # assocs = descendent[var_name]
-          move_assocs(var_name, descendent)
-        end
-      end
-
-      def merge_vars(descendent)
-        descendent.vars.each_value { |vr| add_var(vr) }
-      end
-    end # class
-  end # module
-end # module

data/lib/mini_kraken/core/equals.rb

@@ -1,191 +0,0 @@
-# frozen_string_literal: true
-
-require 'singleton'
-require_relative 'binary_relation'
-require_relative '../composite/cons_cell_visitor'
-require_relative 'duck_fiber'
-require_relative 'log_var'
-require_relative 'log_var_ref'
-
-module MiniKraken
-  module Core
-    # equals tries to unify two terms
-    class Equals < BinaryRelation
-      include Singleton
-
-      def initialize
-        super('equals', '==')
-      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)
-        arg1, arg2 = *actuals
-        DuckFiber.new(:custom) do
-          outcome = unification(arg1, arg2, anEnv)
-          outcome.prune!
-        end
-      end
-
-      def unification(arg1, arg2, anEnv)
-        arg1_nil = arg1.nil?
-        arg2_nil = arg2.nil?
-        if arg1_nil || arg2_nil
-          if arg1_nil && arg2_nil
-            result = Outcome.success(anEnv)
-          else
-            result = Outcome.failure(anEnv)
-          end
-          return result
-        end
-        new_arg1, new_arg2 = commute_cond(arg1, arg2, anEnv)
-        do_unification(new_arg1, new_arg2, anEnv)
-      end
-
-      private
-
-
-      # table: Unification
-      # | arg1               | arg2               | Criterion                                 || Unification              |
-      # | isa? Atomic        | isa? Atomic        | arg1.eq? arg2 is true                     || { "s", [] }              |
-      # | isa? Atomic        | isa? Atomic        | arg1.eq? arg2 is false                    || { "u", [] }              |
-      # | isa? CompositeTerm | isa? Atomic        | dont_care                                 || { "u", [] }              |
-      # | isa? CompositeTerm | isa? CompositeTerm | unification(arg1.car, arg2.car) => "s"    || { "s", [bindings*] }     |
-      # | isa? CompositeTerm | isa? CompositeTerm | unification(arg1.cdr, arg2.cdr) => "u"    || { "u", [] )              |             |
-      # | isa? LogVarRef   | isa? Atomic        | arg1.fresh? is true                       || { "s", [arg2] }          |
-      # | isa? LogVarRef   | isa? Atomic        | arg1.fresh? is false                      ||                          |
-      # |                                         |   unification(arg1.value, arg2) => "s"    || { "s", [bindings*] }     |
-      # |                                         |   unification(arg1.value, arg2) => "u"    || { "u", [] }              |
-      # | isa? LogVarRef   | isa? CompositeTerm | arg1.fresh? is true                       || { "s", [arg2] }          |  # What if arg1 occurs in arg2?
-      # | isa? LogVarRef   | isa? CompositeTerm | arg1.fresh? is false                      ||                          |
-      # |                                         |   unification(arg1.value, arg2) => "s"    || { "s", [bindings*] }     |
-      # |                                         |   unification(arg1.value, arg2) => "u"    || { "u", [] }              |
-      # | isa? LogVarRef   | isa? LogVarRef   | arg1.fresh?, arg2.fresh? => [true, true]  || { "s", [arg1 <=> arg2] } |
-      # | isa? LogVarRef   | isa? LogVarRef   | arg1.fresh?, arg2.fresh? => [true, false] ||                          |
-      # |                                         |   unification(arg1, arg2.value) => "s"    || { "s", [bindings*] }     |
-      # |                                         |   unification(arg1, arg2.value) => "u"    || { "u", [] }              |
-      # | isa? LogVarRef   | isa? LogVarRef   | arg1.fresh?, arg2.fresh? => [false, false]||                          |
-      # |                                         |   unification(arg1, arg2.value) => "s"    || { "s", [bindings*] }     |
-      # |                                         |   unification(arg1, arg2.value) => "u"    || { "u", [] }
-      def do_unification(arg1, arg2, anEnv)
-        # require 'debug'
-        return Outcome.success(anEnv) if arg1.equal?(arg2)
-
-        result = Outcome.failure(anEnv) # default case
-
-        if arg1.kind_of?(Atomic::AtomicTerm)
-          result = Outcome.success(anEnv) if arg1.eql?(arg2)
-        elsif arg1.kind_of?(Composite::CompositeTerm)
-          if arg2.kind_of?(Composite::CompositeTerm) # Atomic::AtomicTerm is default case => fail
-            result = unify_composite_terms(arg1, arg2, anEnv)
-          end
-        elsif arg1.kind_of?(LogVarRef)
-          arg1_freshness = arg1.freshness(anEnv)
-          if arg2.kind_of?(Atomic::AtomicTerm)
-            if arg1_freshness.degree == :fresh
-              result = Outcome.success(anEnv)
-              arg1.associate(arg2, result)
-            else
-              result = Outcome.success(anEnv) if arg1.value(anEnv).eql?(arg2)
-            end
-          elsif arg2.kind_of?(Composite::CompositeTerm)
-            if arg1_freshness.degree == :fresh
-              result = Outcome.success(anEnv)
-              arg1.associate(arg2, result)
-            else
-              # Ground case...
-              arg1_associated = arg1_freshness.associated
-              unless arg1_associated.kind_of?(Atomic::AtomicTerm)
-                result = unify_composite_terms(arg1_associated, arg2, anEnv)
-              end
-            end
-          elsif arg2.kind_of?(LogVarRef)
-            freshness = [arg1.fresh?(anEnv), arg2.fresh?(anEnv)]
-            case freshness
-            when [false, false] # TODO: confirm this...
-              result = unification(arg1.value(anEnv), arg2.value(anEnv), anEnv)
-            when [true, true]
-              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
-          else
-            arg_kinds = [arg1.class, arg2.class]
-            raise StandardError, "Unsupported combination #{arg_kinds}"
-          end
-        end
-
-        result
-      end
-
-      # @param arg1 [Composite::ConsCell]
-      # @param arg2 [Composite::ConsCell]
-      # @return [Outcome]
-      def unify_composite_terms(arg1, arg2, anEnv)
-        # require 'debug'
-        result = Outcome.success(anEnv)
-        # We'll do parallel iteration
-        visitor1 = Composite::ConsCellVisitor.df_visitor(arg1)
-        visitor2 = Composite::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, Atomic::AtomicTerm, Composite::ConsCell, LogVarRef
-              when [Composite::ConsCell, Composite::ConsCell]
-                skip_children1 = false
-                skip_children2 = false
-              when [Composite::ConsCell, LogVarRef]
-                skip_children1 = true
-                skip_children2 = false
-                sub_result = unification(cell1, cell2, anEnv)
-                result = merge_results(result, sub_result)
-              when [LogVarRef, Composite::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
-          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
-  end # module
-end # module

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,102 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_arg'
-require_relative '../composite/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.
-    class GoalTemplate < BaseArg
-      # @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
-      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)
-          elsif arg.kind_of?(Composite::ConsCell)
-            # if list contains a formal_ref it must be replaced by the actual
-            goal_args << transform(arg, formals2actuals)
-          else
-            goal_args << arg
-          end
-        end
-
-        Goal.new(relation, goal_args)
-      end
-
-      private
-
-      def transform(aConsCell, formals2actuals)
-        return aConsCell if aConsCell.null?
-
-        member = { car: :@car, cdr: :@cdr }
-        visitor = Composite::ConsCellVisitor.df_visitor(aConsCell)
-        side, cell = visitor.resume
-        result = Composite::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 Composite::ConsCell
-              converted = Composite::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?(Composite::ConsCell)
-        end
-
-        result
-      end
-    end # class
-  end # module
-end # module