mini_kraken 0.1.01 → 0.1.02

data/lib/mini_kraken/core/cons_cell.rb

@@ -0,0 +1,44 @@
+require_relative 'composite_term'
+
+module MiniKraken
+  module Core
+    class ConsCell < CompositeTerm
+      attr_reader :car
+      attr_reader :cdr
+
+      def initialize(obj1, obj2 = nil)
+        @car = obj1
+        @cdr = obj2
+      end
+
+      def children
+        [car, cdr]
+      end
+
+      # Return true if it is an empty list, otherwise false.
+      # A list is empty, when both car and cdr fields are nil.
+      def null?
+        car.nil? && cdr.nil?
+      end
+
+      def ==(other)
+        return false unless other.respond_to?(:car)
+        (car == other.car) && (cdr == other.cdr)
+      end
+
+      def eql?(other)
+        (self.class == other.class) && car.eql?(other.car) && cdr.eql?(other.cdr)
+      end
+      
+      def quote(anEnv)
+        return self if null?
+        new_car = car.nil? ? nil : car.quote(anEnv)
+        new_cdr = cdr.nil? ? nil : cdr.quote(anEnv)        
+        ConsCell.new(new_car, new_cdr)
+      end
+    end # class
+
+    # Constant representing the null (empty) list.
+    NullList = ConsCell.new(nil, nil).freeze
+  end # module
+end # module

data/lib/mini_kraken/core/duck_fiber.rb

@@ -0,0 +1,44 @@
+require_relative 'outcome'
+
+module MiniKraken
+  module Core
+    # A mock class that mimicks the behavior of a Fiber instance.
+    class DuckFiber
+      # @return [Outcome] The sole outcome to yield.
+      attr_reader :outcome
+
+      # @return [Symbol] one of: :initial, :yielded
+      attr_reader :state
+
+      # @param outcomeKind [Symbol] One of: :failure, :basic_success, :custom
+      def initialize(outcomeKind, &customization)
+        @state = :initial
+        if outcomeKind == :custom && block_given?
+          @outcome = customization.call
+        else
+          @outcome = valid_outcome(outcomeKind)
+        end
+      end
+
+      def resume(*_args)
+        if state == :initial
+          @state = :yielded
+          return outcome
+        else
+          return nil
+        end
+      end
+      
+      def valid_outcome(outcomeKind)
+        case outcomeKind
+          when :failure
+            Failure
+          when :success
+            BasicSuccess
+          else
+            raise StandardError, "Unknonw outcome kind #{outcomeKind}"
+        end
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/environment.rb

@@ -0,0 +1,59 @@
+require_relative 'vocabulary'
+
+module MiniKraken
+  module Core
+    class Environment
+      include Vocabulary  # Use mix-in module
+
+      # @return [Hash] Pairs of the kind {String => Variable}
+      attr_reader :vars
+
+      # @param aParent [Environment, NilClass] Parent environment to this one.
+      def initialize(aParent = nil)
+        init_vocabulary(aParent)
+        @vars = {}
+      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
+      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.resume
+          break if env.nil?
+          env.do_propagate(descendent) if env.kind_of?(Environment) 
+        end until env.equal?(self)
+      end
+
+      # Move associations from descendent outcome object
+      def do_propagate(descendent)
+        return unless descendent.successful? 
+
+        vars.each_key do |var_name|
+          assocs = descendent[var_name]
+          assocs.each do |assoc|
+            own = self[var_name]
+            add_assoc(assoc) unless assoc.equal?(own)
+          end
+          descendent.associations.delete(var_name) unless assocs.empty?
+        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

@@ -0,0 +1,216 @@
+require 'singleton'
+require_relative 'binary_relation'
+# require_relative 'any_value'
+require_relative 'duck_fiber'
+require_relative 'variable'
+require_relative 'variable_ref'
+
+module MiniKraken
+  module Core
+    # equals tries to unify two terms
+    class Equals < BinaryRelation
+      include Singleton
+
+      def initialize
+        super('equals', '==')
+      end
+
+=begin
+    double data flow:
+      A goal has actual arguments
+      When its corresponding relation is invoked
+      this one will return two things: (a success, the bindings/constraints
+      resulting from the relation)
+      the bindings/constraints can be undone if enclosing fails, otherwise
+      the bindings/constraints are rolled up.
+=end
+=begin
+      def unify(aGoal, vars)
+        arg1, arg2 = aGoal.actuals
+        arg_kinds = [arg1.kind_of?(VariableRef), arg2.kind_of?(VariableRef)]
+        case arg_kinds
+        when [false, false]
+          if arg1.eql?(arg2)
+            result = Outcome.new(:"#s", [])
+          else
+            result = Failure
+          end
+        when [false, true]
+          if arg2.fresh?
+            arg2.bind_to(arg1)
+            result = Outcome.new(:"#s", [arg1])
+          else
+            if arg2.value.eql?(arg1)
+              result = Outcome.new(:"#s", [arg1])
+            else
+              result = Failure
+            end
+          end
+        when [true, false]
+          if arg1.fresh?
+            arg1.bind_to(arg2)
+            result = Outcome.new(:"#s", [arg2])
+          else
+            if arg1.value.eql?(arg2)
+              result = Outcome.new(:"#s", [arg2])
+            else
+              result = Failure
+            end
+          end
+        when [true, true]
+          case [arg1.fresh?, arg2.fresh?]
+          when [false, false]
+            if arg1.value == arg2.value
+              result = Outcome.new(:"#s", [arg1.value])
+            else
+              result = Failure
+            end
+          when [false, true]
+            arg2.bind_to(arg1)
+            result = Outcome.new(:"#s", arg1.value)
+          when [true, false]
+            arg1.bind_to(arg2)
+            result = Outcome.new(:"#s", arg2.value)
+          when [true, true]
+            if arg1.variable.name == arg2.variable.name
+              result = Outcome.new(:"#s", [])
+            else
+              # TODO: add constraints
+              result = Outcome.new(:"#s", [])
+            end
+          end
+        end
+
+        result
+      end
+=end
+
+    def solver_for(actuals, anEnv)
+      arg1, arg2 = *actuals
+      DuckFiber.new(:custom) { unification(arg1, arg2, anEnv) }
+    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.new(:"#s", anEnv)
+        else
+          result = Failure
+        end
+        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
+    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? VariableRef   | isa? Atomic        | arg1.fresh? is true                       || { "s", [arg2] }          |
+    # | isa? VariableRef   | isa? Atomic        | arg1.fresh? is false                      ||                          |
+    # |                                         |   unification(arg1.value, arg2) => "s"    || { "s", [bindings*] }     |
+    # |                                         |   unification(arg1.value, arg2) => "u"    || { "u", [] }              |
+    # | isa? VariableRef   | isa? CompositeTerm | arg1.fresh? is true                       || { "s", [arg2] }          |  # What if arg1 occurs in arg2?
+    # | isa? VariableRef   | isa? CompositeTerm | arg1.fresh? is false                      ||                          |
+    # |                                         |   unification(arg1.value, arg2) => "s"    || { "s", [bindings*] }     |
+    # |                                         |   unification(arg1.value, arg2) => "u"    || { "u", [] }              |
+    # | isa? VariableRef   | isa? VariableRef   | arg1.fresh?, arg2.fresh? => [true, true]  || { "s", [arg1 <=> arg2] } |
+    # | isa? VariableRef   | isa? VariableRef   | arg1.fresh?, arg2.fresh? => [true, false] ||                          |
+    # |                                         |   unification(arg1, arg2.value) => "s"    || { "s", [bindings*] }     |
+    # |                                         |   unification(arg1, arg2.value) => "u"    || { "u", [] }              |
+    # | isa? VariableRef   | isa? VariableRef   | 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.new(:"#s", anEnv) if arg1.equal?(arg2)
+      result = Outcome.new(:"#u", anEnv) # default case
+
+      if arg1.kind_of?(AtomicTerm)
+        result = BasicSuccess if arg1.eql?(arg2)
+      elsif arg1.kind_of?(CompositeTerm)
+        if arg2.kind_of?(CompositeTerm) # AtomicTerm is default case => fail
+          result = unify_composite_terms(arg1, arg2, anEnv)
+        end
+      elsif arg1.kind_of?(VariableRef)
+        arg1_freshness = arg1.freshness(anEnv)
+        if arg2.kind_of?(AtomicTerm)
+          if arg1_freshness.degree == :fresh
+            result = Outcome.new(:"#s", anEnv)
+            arg1.associate(arg2, result)
+          else
+            result = Outcome.new(:"#s", anEnv) if arg1.value(anEnv).eql?(arg2)
+          end
+        elsif arg2.kind_of?(CompositeTerm)
+          if arg1_freshness.degree == :fresh
+            result = Outcome.new(:"#s", anEnv)
+            arg1.associate(arg2, result)
+          else
+            # Ground case...
+            result = unify_composite_terms(arg1_freshness.associated, arg2, anEnv)
+          end
+        elsif arg2.kind_of?(VariableRef)
+          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.new(:"#s", anEnv) 
+            if arg1.var_name != arg2.var_name
+              arg1.associate(arg2, result) 
+              arg2.associate(arg1, result)
+            end
+          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
+
+  # @return [Freshness]
+    def unify_composite_terms(arg1, arg2, anEnv)
+      # require 'debug'
+      result = Outcome.new(:"#u", 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.new(:"#s", anEnv)
+          associations = subresults.reduce(memo) do |sub_total, outcome|
+            sub_total.merge(outcome)
+            sub_total
+          end
+          result = memo
+        end
+      end
+
+      result
+    end
+
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/fail.rb

@@ -1,17 +1,20 @@
 require 'singleton'
+require_relative 'duck_fiber'
 require_relative 'nullary_relation'
 
 module MiniKraken
   module Core
+    # A nullary relation that unconditionally always fails.
     class Fail < NullaryRelation
       include Singleton
-      
+
       def initialize
-        super('fail')
+        super('fail', '#u')
       end
-      
-      def unify(aGoal, vars)
-        []
+
+      # @return [DuckFiber]
+      def solver_for(_actuals, _env)
+        DuckFiber.new(:failure)
       end
     end # class
   end # module

data/lib/mini_kraken/core/freshness.rb

@@ -0,0 +1,42 @@
+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?
+        self.degree == :fresh
+      end
+
+      def bound?
+        self.degree == :bound
+      end
+
+      def ground?
+        self.degree == :ground
+      end
+
+      # Does this instance represent something fresh according to
+      # "Reasoned Schemer" book ?
+      def rs_fresh?
+        self.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.rb

@@ -1,17 +1,42 @@
+require_relative 'environment'
+
 module MiniKraken
   module Core
     class Goal
+      # @return [Relation] The relation corresponding to this goal
       attr_reader :relation
 
+      # @return [Array<Term>] The actual aguments of the goal
+      attr_reader :actuals
+
+      # @param aRelation [Relation] The relation corresponding to this goal
+      # @param args [Array<Term>] The actual aguments of the goal
       def initialize(aRelation, args)
         @relation = aRelation
+        @actuals = validated_actuals(args)
+      end
+
+      # Attempt to achieve the goal for a given context (environment)
+      # @param anEnv [Environment] The context in which the goal take place.
+      # @return [Fiber<Outcome>] A Fiber object that will generate the results.
+      def attain(anEnv)
+        relation.solver_for(actuals, anEnv)
       end
-      
-      def attain(aPublisher, vars)
-        aPublisher.broadcast_entry(self, vars)
-        outcome = relation.unify(self, vars)
-        aPublisher.broadcast_exit(self, vars, outcome)
-        outcome
+
+      private
+
+      def validated_actuals(args)
+        if args.size != relation.arity
+          err_msg = "Goal has #{args.size} arguments, expected #{relation.arity}"
+          raise StandardError, err_msg
+        end
+
+        prefix = "Invalid goal argument "
+        args.each do |actl|
+          raise StandardError, prefix + actl.to_s unless actl.kind_of?(Term)
+        end
+
+        args.dup
       end
     end # class
   end # module