mini_kraken 0.1.01 → 0.1.02

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e60a12ea5711e80f10de8f1a2c018199975fc83baeecab2d15fdb2ea6c6b91c3
-  data.tar.gz: 8fd4f903f896ac08e13f00881592b7e81e4684f7eb9acd2f7be9d4b03fee6a2d
+  metadata.gz: d6ff930902d2d1d8967acaab13146a2f1f884b4dab5cdf5dc23b14e043baac76
+  data.tar.gz: 702bd83538e9e94edac5e17943af72438d3c91296221c80e6172d1cbbf1df71c
 SHA512:
-  metadata.gz: e5f333b6bfbb58f2726c1351fa672c95c1b3b171c322411ce87617f0a4e748f8bab1beecb0a4fc035dc15ec9ae382d2b1dd3fcd59707a37402db33a12248a878
-  data.tar.gz: '0196ee55adc9516fa4cfcea24dd74ec33b061771e9c273543d648d00b1244038d6c945a95b76f44c1c7f02f853f92a32a541ea051d5d6d5facf9d307640a2e13'
+  metadata.gz: 4885be585b956b690762ff66365098d4ed0cd6bd141410863afa1701431f6cc4fc6749fc5a2fff4e2689cbd3f9ac7035f057458de2b364df6a34015a252deaed
+  data.tar.gz: 6180e86da36cdb2d2d3fd0daf6e53061513064b40df79980f36c73d97418e0016c5985bb03d573a338508a8c2d1745dfa2340c62c261177716d57ec4676e5cba

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+## [0.1.02] - 2020-04-28
+Major code refactoring. Passes all frames 1:1 up to 1:36 of "Reasoned Schemer" book
+
 ## [0.1.01] - 2020-03-01
 First code commit
 ### Added

data/README.md

@@ -1,8 +1,5 @@
 # MiniKraken
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/mini_kraken`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
 
 ## Installation
 

data/lib/mini_kraken/core/any_value.rb

@@ -0,0 +1,29 @@
+module MiniKraken
+  module Core
+    class AnyValue
+      attr_reader :rank
+      
+      def initialize(aRank)
+        @rank = aRank
+      end
+      
+      def ==(other)
+        rank == other.rank
+      end
+      
+      # Use same text representation as in Reasoned Schemer.
+      def to_s
+        "_#{rank}"
+      end
+      
+      def ground?(_env)
+        false
+      end
+      
+      # @return [AnyValue]
+      def quote(_env)
+        self
+      end      
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/association.rb

@@ -0,0 +1,21 @@
+module MiniKraken
+  module Core
+    # A record that a given vairable is associated with a value.
+    class Association
+      # @return [String] name of the variable beig association the value.
+      attr_reader :var_name
+      
+      # @return [Term] the MiniKraken value associated with the variable
+      attr_reader :value
+      
+      
+      # @param aVariable [Variable, String] A variable or its name.
+      # @param aValue [Term] value being associated to the variable.
+      def initialize(aVariable, aValue)
+        @var_name = aVariable.respond_to?(:name) ? aVariable.name : aVariable
+        @value = aValue
+      end
+      
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/association_walker.rb

@@ -0,0 +1,179 @@
+require 'set'
+require_relative 'atomic_term'
+require_relative 'composite_term'
+
+module MiniKraken
+  module Core
+    class AssociationWalker
+      attr_reader :visitees
+
+      def initialize
+        @visitees = Set.new
+      end
+
+      # @param aName [String]
+      # @param anEnv [Vocabulary]
+      # @return [Term, NilClass]
+      def find_ground(aName, anEnv)
+        # require 'debug'
+        assocs = anEnv[aName]
+        walk_assocs(assocs, anEnv)
+      end
+
+      def walk_assocs(assocs, anEnv)
+        # Treat easy cases first...
+        return nil if assocs.empty?
+        assoc_atomic = assocs.find { |assc| assc.value.kind_of?(AtomicTerm) }
+        return assoc_atomic.value if assoc_atomic
+
+        result = nil
+        assocs.each do |assc|
+          unless visitees.include?(assc)
+            visitees.add(assc)
+            sub_result = walk_value(assc.value, anEnv)
+            if sub_result
+              result = sub_result
+              break
+            end
+          end
+        end
+
+        result
+      end
+
+      def walk_value(aTerm, anEnv)
+        return aTerm if aTerm.kind_of?(AtomicTerm) || aTerm.kind_of?(AnyValue)
+        result = nil
+
+        if aTerm.kind_of?(CompositeTerm)
+          children = aTerm.children.compact
+          walk_results = children.map do |child|
+            walk_value(child, anEnv)
+          end
+          result = aTerm unless walk_results.any?(&:nil?)
+        else # VariableRef or Variable
+          name = aTerm.respond_to?(:name) ? aTerm.name : aTerm.var_name
+          result = find_ground(name, anEnv)
+        end
+
+        result
+      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 aTerm [Term]
+      # @param anEnv [Vocabulary]
+      # @return [Freshness]
+      def determine_freshness(aTerm, anEnv)
+        # require 'debug'
+        result = nil
+
+        if aTerm.kind_of?(AtomicTerm)
+          result = Freshness.new(:ground, aTerm)
+        elsif aTerm.kind_of?(CompositeTerm)
+          children = aTerm.children.compact
+          walk_results = children.map { |chd| determine_freshness(chd, anEnv) }
+
+          degree = nil
+          if walk_results.all?(&:fresh?)
+            degree = :fresh
+          elsif walk_results.all?(&:ground?)
+            degree = :ground
+          else
+            degree = :bound
+          end
+          result = Freshness.new(degree, aTerm)
+        else # VariableRef or Variable
+          name = aTerm.respond_to?(:name) ? aTerm.name : aTerm.var_name
+          assocs = anEnv[name]
+          if assocs.empty?
+            result = Freshness.new(:fresh, nil)
+          else
+            result = freshness_associated(assocs, anEnv)
+          end
+        end
+
+        result
+      end
+
+      def freshness_associated(assocs, anEnv)
+        assoc_atomic = assocs.find { |assc| assc.value.kind_of?(AtomicTerm) }
+        return Freshness.new(:ground, assoc_atomic.value) if assoc_atomic
+
+        raw_results = assocs.map do |assc|
+          unless visitees.include?(assc)
+            visitees.add(assc)
+            determine_freshness(assc.value, anEnv)
+          end
+        end
+
+        raw_results.compact!
+        result = nil
+        if raw_results.all?(&:fresh?)
+          # TODO: What if multiple bindings?...
+          result = Freshness.new(:bound, assocs[0].value)
+        elsif raw_results.any?(&:ground?)
+          ground_value = raw_results.find(&:ground?).associated
+          result = Freshness.new(:ground, ground_value)
+        else
+          # TODO: What if multiple bindings?...
+          result = Freshness.new(:bound, raw_results[0].associated)
+        end
+
+        result
+      end
+
+      def quote_term(aTerm, anEnv)
+        # require 'debug'
+        result = nil
+
+        if aTerm.kind_of?(AtomicTerm)
+          result = aTerm.quote(anEnv)
+        elsif aTerm.kind_of?(ConsCell)
+          result = aTerm.quote(anEnv)
+        else # VariableRef or Variable
+          name = aTerm.respond_to?(:name) ? aTerm.name : aTerm.var_name
+          assocs = anEnv[name]
+          if assocs.empty?
+            result = nil
+          else
+            result = quote_associated(assocs, anEnv)
+          end
+        end
+
+        result
+      end
+
+      def quote_associated(assocs, anEnv)
+        assoc_atomic = assocs.find { |assc| assc.value.kind_of?(AtomicTerm) }
+        return assoc_atomic.value if assoc_atomic
+
+        raw_results = assocs.map do |assc|
+          unless visitees.include?(assc)
+            visitees.add(assc)
+            quote_term(assc.value, anEnv)
+          end
+        end
+
+        raw_results.compact!
+        result = nil
+        if raw_results.empty?
+          result = nil
+        elsif raw_results.all? { |res| res.fresh?(anEnv) }
+          # TODO: What if multiple bindings?...
+          result = quote_term(assocs[0].value, anEnv)
+        elsif raw_results.any? { |res| res.ground?(anEnv) }
+          ground_res = raw_results.find { |res| res.ground?(anEnv) }
+          result = quote_term(ground_res, anEnv)
+        else
+          # TODO: What if multiple bindings?...
+          result = quote_term(raw_results[0], anEnv)
+        end
+
+        result
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/atomic_term.rb

@@ -0,0 +1,64 @@
+require_relative 'term'
+require_relative 'freshness'
+
+module MiniKraken
+  module Core
+    # An atomic term is an elementary Minikraken term that cannot be
+    # decomposed into simpler MiniKraken data value(s).
+    class AtomicTerm < Term
+      # @return [Object] Internal representation of a MiniKraken data value
+      attr_reader :value
+
+      # @param aValue [Object] Ruby representation of MiniKraken data value
+      def initialize(aValue)
+        @value = aValue
+        @value.freeze
+      end
+
+      # An atomic term is by definition a ground term: since it doesn't contain
+      # any bound variable (in Prolog sense).
+      # @param _env [Vocabulary]
+      # @return [Freshness]
+      def freshness(_env)
+        Freshness.new(:ground, self)
+      end
+      
+      # An atomic term is a ground term: by definition it doesn't contain
+      # any fresh variable.
+      # @param _env [Vocabulary]
+      # @return [FalseClass]
+      def fresh?(_env)
+        false
+      end      
+
+      # An atomic term is a ground term: by definition it doesn't contain
+      # any fresh variable.
+      # @param _env [Vocabulary]
+      # @return [TrueClass]
+      def ground?(_env)
+        true
+      end
+
+      # @return [AtomicTerm]
+      def quote(_env)
+        self
+      end
+
+      # Data equality testing
+      # @return [Boolean]
+      def ==(other)
+        if other.respond_to?(:value)
+          value == other.value
+        else
+          value == other
+        end
+      end
+
+      # Type and data equality testing
+      # @return [Boolean]
+      def eql?(other)
+        (self.class == other.class) && value.eql?(other.value)
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/binary_relation.rb

@@ -0,0 +1,61 @@
+require_relative 'relation'
+require_relative 'composite_term'
+
+module MiniKraken
+  module Core
+    class BinaryRelation < Relation
+      # @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
+        2
+      end
+      
+      protected
+      
+      # table: Commute
+      # |arg1                | arg2               | arg2.ground? || Commute |
+      # | isa? Atomic        | isa? Atomic        | dont_care    || Yes     |
+      # | isa? Atomic        | isa? CompositeTerm | dont_care    || Yes     |
+      # | isa? Atomic        | isa? VariableRef   | dont_care    || Yes     |
+      # | isa? CompositeTerm | isa? Atomic        | true         || No      |
+      # | isa? CompositeTerm | isa? CompositeTerm | false        || Yes     |
+      # | isa? CompositeTerm | isa? CompositeTerm | true         || No      |
+      # | isa? CompositeTerm | isa? VariableRef   | dont_care    || Yes     |
+      # | isa? VariableRef   | isa? Atomic        | dont_care    || No      |
+      # | isa? VariableRef   | isa? CompositeTerm | dont_care    || No      |
+      # | isa? VariableRef   | isa? VariableRef   | false        || Yes     |
+      # | isa? VariableRef   | isa? VariableRef   | true         || No      |
+      def commute_cond(arg1, arg2, env)
+        commuting = true
+        arg2_is_var_ref = arg2.kind_of?(VariableRef)
+
+        if arg1.kind_of?(CompositeTerm)
+          if arg2_is_var_ref
+            commuting = true
+          else
+            commuting = !arg2.ground?(env)
+          end
+        elsif arg1.kind_of?(VariableRef)
+          if arg2_is_var_ref
+            commuting = !arg2.ground?(env)
+          else
+            commuting = false
+          end
+        end
+
+        if commuting
+          [arg2, arg1]
+        else
+          [arg1, arg2]
+        end
+      end      
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/composite_term.rb

@@ -0,0 +1,54 @@
+require_relative 'term'
+require_relative 'freshness'
+
+module MiniKraken
+  module Core
+    # An composite term is an Minikraken term that can be
+    # decomposed into simpler MiniKraken data value(s).
+    class CompositeTerm < Term
+
+      def children
+        raise NotImplementedError, 'This method must re-defined in subclass(es).'
+      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 _env [Vocabulary]
+      # @return [Freshness]      
+      def freshness(_env)
+         env.freshness_composite(self)
+      end
+
+      # @param env [Environment]
+      # @return [Boolean]
+      def fresh?(env)
+        env.fresh_value?(self)
+      end
+
+      # A composite is ground if all its children are ground
+      def ground?(anEnv)
+        children.all? do |child|
+          child.nil? || child.ground?(anEnv)
+        end
+      end
+
+      # # Data equality testing
+      # # @return [Boolean]
+      # def ==(other)
+        # if other.respond_to?(:value)
+          # value == other.value
+        # else
+          # value == other
+        # end
+      # end
+
+      # # Type and data equality testing
+      # # @return [Boolean]
+      # def eql?(other)
+        # (self.class == other.class) && value.eql?(other.value)
+      # end
+    end # class
+  end # module
+end # module