mini_kraken 0.1.04 → 0.1.09

data/lib/mini_kraken/core/fail.rb

@@ -1,21 +1,27 @@
+# frozen_string_literal: true
+
 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
+unless MiniKraken::Core.constants(false).include? :Fail
+  module MiniKraken
+    module Core
+      # A nullary relation that unconditionally always fails.
+      class Fail < NullaryRelation
+        include Singleton
+
+        def initialize
+          super('fail', '#u')
+        end
 
-      def initialize
-        super('fail', '#u')
-      end
+        # @return [DuckFiber]
+        def solver_for(_actuals, _env)
+          DuckFiber.new(:failure)
+        end
+      end # class
 
-      # @return [DuckFiber]
-      def solver_for(_actuals, _env)
-        DuckFiber.new(:failure)
-      end
-    end # class
+      Fail.instance.freeze
+    end # module
   end # module
-end # module
+end # unless

data/lib/mini_kraken/core/freshness.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MiniKraken
   module Core
     # Freshness: fresh, bound, ground
@@ -12,31 +14,32 @@ module MiniKraken
       def initialize(aDegree, anAssociated)
         super(aDegree, valid_associated(anAssociated))
       end
-      
+
       def fresh?
-        self.degree == :fresh
+        degree == :fresh
       end
 
       def bound?
-        self.degree == :bound
+        degree == :bound
       end
 
       def ground?
-        self.degree == :ground
+        degree == :ground
       end
 
       # Does this instance represent something fresh according to
       # "Reasoned Schemer" book ?
       def rs_fresh?
-        self.degree != ground
+        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
+end # module

data/lib/mini_kraken/core/goal.rb

@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+
 require_relative 'environment'
 
 module MiniKraken
+  require_relative 'goal_arg'
+
   module Core
-    class Goal
+    class Goal < GoalArg
       # @return [Relation] The relation corresponding to this goal
       attr_reader :relation
 
@@ -31,13 +35,13 @@ module MiniKraken
           raise StandardError, err_msg
         end
 
-        prefix = "Invalid goal argument "
+        prefix = 'Invalid goal argument '
         args.each do |actl|
-          raise StandardError, prefix + actl.to_s unless actl.kind_of?(Term)
+          raise StandardError, prefix + actl.to_s unless actl.kind_of?(GoalArg)
         end
 
         args.dup
       end
     end # class
   end # module
-end # module
+end # module

data/lib/mini_kraken/core/goal_arg.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module MiniKraken
+  module Core
+    # The generalization of any iem that can be
+    # passed as arugement to a goal.
+    class GoalArg
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/goal_relation.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'relation'
+
+module MiniKraken
+  module Core
+    # A specialization of a relation that accepts only goal(s)
+    # as its arguments.
+    class GoalRelation < Relation
+      def arity
+        2
+      end
+
+      protected
+
+      def validated_args(actuals)
+        actuals.each do |arg|
+          unless arg.kind_of?(Goal)
+            prefix = "#{name} expects goal as argument, found a "
+            raise StandardError, prefix + "'#{arg.class}'"
+          end
+        end
+
+        actuals
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/k_integer.rb

@@ -1,15 +1,16 @@
+# frozen_string_literal: true
+
 require_relative 'atomic_term'
 
 module MiniKraken
   module Core
     # A specialized atomic term that represents an integer value.
-    # in MiniKraken 
+    # 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
+end # module

data/lib/mini_kraken/core/k_symbol.rb

@@ -1,15 +1,16 @@
+# frozen_string_literal: true
+
 require_relative 'atomic_term'
 
 module MiniKraken
   module Core
     # A specialized atomic term that represents a symbolic value.
-    # in MiniKraken   
+    # 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
+end # module

data/lib/mini_kraken/core/nullary_relation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'relation'
 
 module MiniKraken
@@ -17,4 +19,4 @@ module MiniKraken
       end
     end # class
   end # module
-end # module
+end # module

data/lib/mini_kraken/core/outcome.rb

@@ -1,35 +1,39 @@
+# frozen_string_literal: true
+
 require_relative 'vocabulary'
 
-module MiniKraken
-  module Core
-    class Outcome
-      include Vocabulary # Use mix-in module
+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
+        # @return [Symbol] One of: :"#s" (success), :"#u" (failure)
+        attr_reader :resultant
 
-      def initialize(aResult, aParent = nil)
-        init_vocabulary(aParent)
-        @resultant = aResult
-      end
+        def initialize(aResult, aParent = nil)
+          init_vocabulary(aParent)
+          @resultant = aResult
+        end
 
-      def successful?
-        self.resultant == :"#s"
-      end
+        def successful?
+          resultant == :"#s"
+        end
 
-      def ==(other)
-        are_equal = false
+        def ==(other)
+          are_equal = false
 
-        if resultant == other.resultant && parent == other.parent &&
-          associations == other.associations
-          are_equal = true
-        end
+          if resultant == other.resultant && parent == other.parent &&
+             associations == other.associations
+            are_equal = true
+          end
 
-        are_equal
-      end
-    end # class
+          are_equal
+        end
+      end # class
 
-    Failure = Outcome.new(:"#u")
-    BasicSuccess = Outcome.new(:"#s")
+      Failure = Outcome.new(:"#u")
+      BasicSuccess = Outcome.new(:"#s")
+    end # module
   end # module
-end # module
+end # defined

data/lib/mini_kraken/core/relation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MiniKraken
   module Core
     class Relation
@@ -20,25 +22,9 @@ module MiniKraken
         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
+        alt_name || name
       end
     end # class
   end # module
-end # module
+end # module

data/lib/mini_kraken/core/succeed.rb

@@ -1,20 +1,26 @@
+# frozen_string_literal: true
+
 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
+unless MiniKraken::Core.constants(false).include? :Succeed
+  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
 
-      def initialize
-        super('succeed', '#s')
-      end
-      
-      def solver_for(_actuals, _env)
-        DuckFiber.new(:success)
-      end      
-    end # class
+      Succeed.instance.freeze
+    end # module
   end # module
-end # module
+end # unless

data/lib/mini_kraken/core/term.rb

@@ -1,7 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'goal_arg'
+
 module MiniKraken
   module Core
-    # The generalization of data value in MiniKraken
-    class Term
+    # The generalization of any data value that can be
+    # passed as arugement to a goal.
+    class Term < GoalArg
     end # class
   end # module
 end # module

data/lib/mini_kraken/core/variable.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require_relative 'designation'
 require_relative 'any_value'
 require_relative 'vocabulary'
 
@@ -6,26 +9,19 @@ module MiniKraken
     # 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
+      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)
-        @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)
+        init_designation(aName)
+        @i_name = name.dup
       end
 
-      def ground?(anEnvironment)
-        !fresh?(anEnvironment)
+      def fused?
+        name != i_name
       end
 
       def quote(anEnvironment)
@@ -34,16 +30,6 @@ module MiniKraken
         val = anEnvironment.quote_ref(self)
         val.nil? ? AnyValue.new(name, anEnvironment) : 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/variable_ref.rb

@@ -1,44 +1,25 @@
+# frozen_string_literal: true
+
 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
+      include Designation # Mixin: Acquire name attribute
+      alias var_name 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 bound?(env)
-        freshness = env.freshness_ref(self)
-        freshness.degree == :bound
-      end
-
-      # @param env [Environment]
-      # @return [Boolean]
-      def ground?(env)
-        !fresh?(env)
+        init_designation(aName)
       end
 
       # @param aValue [Term]
       # @param env [Environment]
       def associate(aValue, env)
-        assoc = Association.new(var_name, aValue)
-        env.add_assoc(assoc)
+        env.add_assoc(var_name, aValue)
       end
 
       # @param env [Environment]
@@ -54,13 +35,6 @@ module MiniKraken
         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)
@@ -71,34 +45,15 @@ module MiniKraken
       # @param env [Environment]
       # @return [Boolean]
       def fused_with?(another, env)
-        # I should point to 'another'...
-        other_name = another.var_name
-        to_another = values(env).find do |val|
-          val.kind_of?(VariableRef) && val.var_name == other_name
-        end
-        return false unless to_another
+        my_var = env.name2var(var_name)
+        return false unless my_var.fused?
 
-        # 'another' should point to me
-        to_me = another.values(env).find do |val|
-          val.kind_of?(VariableRef) && val.var_name == var_name
-        end
-        !to_me.nil?
+        other_var = env.name2var(another.var_name)
+        return my_var.i_name == other_var.i_name
       end
 
       def names_fused(env)
-        to_others = values(env).select do |val|
-          val.kind_of?(VariableRef)
-        end
-        return [] if to_others.empty?
-
-        # 'others' should point to me
-        to_me = to_others.select do |other|
-          other.values(env).find do |val|
-            val.kind_of?(VariableRef) && val.var_name == var_name
-          end
-        end
-
-        to_me.map { |other| other.var_name }
+        env.names_fused(var_name)
       end
 
       # param another [VariableRef]
@@ -112,13 +67,11 @@ module MiniKraken
 
       def valid_name(aName)
         if aName.empty?
-          raise StandardError, "Variable name may not be empty."
+          raise StandardError, 'Variable name may not be empty.'
         end
 
         aName
       end
-
-
     end # class
   end # module
 end # module