mini_kraken 0.1.01 → 0.1.02

data/lib/mini_kraken/core/k_integer.rb

@@ -0,0 +1,15 @@
+require_relative 'atomic_term'
+
+module MiniKraken
+  module Core
+    # A specialized atomic term that represents an integer value.
+    # in MiniKraken 
+    class KInteger < AtomicTerm
+    
+      # @param aValue [Integer] Ruby representation of integer value
+      def initialize(aValue)
+        super(aValue)
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/k_symbol.rb

@@ -0,0 +1,15 @@
+require_relative 'atomic_term'
+
+module MiniKraken
+  module Core
+    # A specialized atomic term that represents a symbolic value.
+    # in MiniKraken   
+    class KSymbol < AtomicTerm
+    
+      # @param aValue [Symbol] Ruby representation of symbol value
+      def initialize(aValue)
+        super(aValue)
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/nullary_relation.rb

@@ -3,9 +3,17 @@ require_relative 'relation'
 module MiniKraken
   module Core
     class NullaryRelation < Relation
-      def initialize(aName)
-        super(aName)
-        @tuple.freeze
+      # @param aName [String] Name of the relation.
+      # @param alternateName [String, NilClass] Alternative name (optional).
+      def initialize(aName, alternateName = nil)
+        super(aName, alternateName)
+        freeze
+      end
+
+      # Number of arguments for the relation.
+      # @return [Integer]
+      def arity
+        0
       end
     end # class
   end # module

data/lib/mini_kraken/core/outcome.rb

@@ -0,0 +1,35 @@
+require_relative 'vocabulary'
+
+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 successful?
+        self.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
+    end # class
+
+    Failure = Outcome.new(:"#u")
+    BasicSuccess = Outcome.new(:"#s")
+  end # module
+end # module

data/lib/mini_kraken/core/relation.rb

@@ -1,16 +1,43 @@
 module MiniKraken
   module Core
     class Relation
+      # @return [String] Name of the relation.
       attr_reader :name
-      attr_reader :tuple
 
-      def initialize(aName)
+      # @return [String, NilClass] Optional alternative name of the relation.
+      attr_reader :alt_name
+
+      # @param aName [String] Name of the relation.
+      # @param alternateName [String, NilClass] Alternative name (optional).
+      def initialize(aName, alternateName = nil)
         @name = aName
-        @tuple = []
+        @alt_name = alternateName
       end
 
+      # Number of arguments for the relation.
+      # @return [Integer]
       def arity
-        tuple.size
+        raise NotImplementedError
+      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 solve(args, anEnv)
+       # Fiber instance responds to resume(*args) message
+        # If too much resume calls => FiberError: dead fiber called message.
+
+        # Fiber.new do |first_yield_arg| do
+          # begin
+            # result = relation.solve(actuals, anEnv)
+            # Fiber.yield result
+          # while result.success?
+
+          nil
+      # end
+
+      def inspect
+        alt_name ? alt_name : name
       end
     end # class
   end # module

data/lib/mini_kraken/core/succeed.rb

@@ -1,8 +1,20 @@
+require 'singleton'
+require_relative 'duck_fiber'
 require_relative 'nullary_relation'
 
 module MiniKraken
   module Core
+    # A nullary relation that unconditionally always fails.
     class Succeed < NullaryRelation
+      include Singleton
+
+      def initialize
+        super('succeed', '#s')
+      end
+      
+      def solver_for(_actuals, _env)
+        DuckFiber.new(:success)
+      end      
     end # class
   end # module
-end # module
+end # module

data/lib/mini_kraken/core/term.rb

@@ -0,0 +1,7 @@
+module MiniKraken
+  module Core
+    # The generalization of data value in MiniKraken
+    class Term
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/variable.rb

@@ -1,11 +1,53 @@
+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
+      # @return [String] Name of the variable
       attr_reader :name
-      
+
+      # @param aName [String] The name of the variable
       def initialize(aName)
-        @name = aName
+        @name = valid_name(aName)
+      end
+
+      def fresh?(anEnvironment)
+        anEnvironment.fresh?(self)
+      end
+
+      # @param env [Environment]
+      # @return [Freshness]
+      def freshness(env)
+        freshness = env.freshness_ref(self)
+      end
+
+      def ground?(anEnvironment)
+        !fresh?(anEnvironment)
+      end
+
+      def quote(anEnvironment)
+        # raise StandardError, "class #{anEnvironment}" unless anEnvironment.kind_of?(Vocabulary)
+        # freshness = anEnvironment.freshness_ref(self)
+        # raise StandardError, "class #{freshness}" unless freshness.kind_of?(Freshness)
+        # raise StandardError, "class #{freshness.associated}" if freshness.associated.kind_of?(Freshness)
+        # freshness.fresh? ? AnyValue.new(0) : freshness.associated.quote(anEnvironment)
+
+        val = anEnvironment.quote_ref(self)
+        val.nil? ? AnyValue.new(0) : val
+      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
+end # module

data/lib/mini_kraken/core/variable_ref.rb

@@ -0,0 +1,76 @@
+require_relative 'term'
+require_relative 'any_value'
+require_relative 'association'
+
+module MiniKraken
+  module Core
+    # A variable reference represents the occurrence of a variable (name) in a
+    # MiniKraken term.
+    class VariableRef < Term
+      # @return [String] Name of the variable
+      attr_reader :var_name
+
+      # @param aName [String] The name of the variable
+      def initialize(aName)
+        @var_name = valid_name(aName)
+      end
+
+      # @param env [Environment]
+      # @return [Boolean]
+      def fresh?(env)
+        env.fresh?(self)
+      end
+
+      # @param env [Environment]
+      # @return [Boolean]
+      def ground?(env)
+        !fresh?(env)
+      end
+
+      # @param aValue [Term]
+      # @param env [Environment]
+      def associate(aValue, env)
+        assoc = Association.new(var_name, aValue)
+        env.add_assoc(assoc)
+      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]
+      # @return [Freshness]
+      def freshness(env)
+        freshness = env.freshness_ref(self)
+      end      
+      
+
+      # @param env [Environment]
+      def quote(env)
+        val = env.quote_ref(self)
+        val.nil? ? AnyValue.new(0) : val
+      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

@@ -0,0 +1,161 @@
+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
+
+      # @param aParent [Environment, NilClass] Parent environment to this one.
+      def init_vocabulary(aParent = nil)
+        @parent = validated_parent(aParent)
+        @associations = {}
+      end
+
+      # Return a Fiber object that can iterate over this vocabulary and
+      # all its direct and indirect parent(s).
+      # @return [Fiber<Vocabulary, NilClass>]
+      def ancestor_walker
+        Fiber.new do
+          relative = self
+          while relative do
+            Fiber.yield relative
+            relative = relative.parent
+          end
+
+          Fiber.yield nil # nil marks end of iteration...
+        end
+      end
+
+      # Record an association between a variable with given name and a term.
+      # @param anAssociation [Association]
+      def add_assoc(anAssociation)
+        name = anAssociation.var_name
+        unless include?(name)
+          err_msg = "Unknown variable '#{name}'."
+          raise StandardError, err_msg
+        end
+        found_assocs = associations[name]
+        if found_assocs
+          found_assocs << anAssociation
+        else
+          associations[name] = [anAssociation]
+        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.
+      def clear
+        associations.clear
+      end
+
+      # Merge the associations from another vocabulary-like object.
+      # @param another [Vocabulary]
+      def merge(another)
+        another.associations.each_pair do |_name, assocs|
+          assocs.each { |a| add_assoc(a) }
+        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, NilClase]
+      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 var [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
+
+      # @param aName [String]
+      # @return [Array<Association>]
+      def [](aName)
+        assoc_arr = associations[aName]
+        assoc_arr = [] if assoc_arr.nil?
+
+        assoc_arr.concat(parent[aName]) if parent
+        assoc_arr
+      end
+
+      # Check that a variable with given name is defined in this vocabulary
+      # of one of its ancestor.
+      # @return [Boolean]
+      def include?(aVarName)
+        var_found = false
+        walker = ancestor_walker
+        loop do
+          voc = walker.resume
+          if voc
+            next unless voc.respond_to?(:vars) && voc.vars.include?(aVarName)
+            var_found = true
+          end
+
+          break
+        end
+
+        var_found
+      end
+
+      protected
+
+      def validated_parent(aParent)
+        if aParent
+          unless aParent.kind_of?(Vocabulary)
+            raise StandardError, "Invalid parent type #{aParent.class}"
+          end
+        end
+
+        aParent
+      end
+    end # class
+  end # module
+end # module