mini_kraken 0.1.04 → 0.1.09

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ef423350ba09d43e77f4fbd981cfb9387f74c0581d19cda817b4db907501de3
-  data.tar.gz: de34208e9dba617b72435c552d4628be97808db2e0b2db27b12b8c31ab865d16
+  metadata.gz: 10a0607b5621effb10eab26d64ff7f52228f93e9c7907b91488613c1d72469aa
+  data.tar.gz: 9b43c9b0d729f2c7944be72f6599decae48d977ea0be5257a365111508473ef9
 SHA512:
-  metadata.gz: dca643b61f43edb431aa3773f9da8e41381823cc0d8af2bb4401d8851cdc5c63994eb0c927e2daf8698b670236db42f4ca9a45d7abcaccd884f51ec9b72f2ac6
-  data.tar.gz: eebe8f8c53bc43c6d26704de26067644a225ad780b1d2aba601dd1a24641a58eaef1b502efba6d37dcf77ea36213145d1be8122f15b5ad48d154012f970bd618
+  metadata.gz: 32c14d82b93ddf21d2b369745b1e556faf1736b53fd7f1782809370777e059c498e1d8347806dc2135aab3bedf429c8d2b93b5f9be4b9b361f86926edb1be20f
+  data.tar.gz: 9b82b3afd53af4da54042f8a8852367250bc8225c1229b31486b4e8223ca533d55f3dcc6250c4de4c03d0d84b77a5e5cf737a6c151f734d7a08334ac442fa330

data/.travis.yml

@@ -3,5 +3,9 @@ sudo: false
 language: ruby
 cache: bundler
 rvm:
-  - 2.6.3
+  - 2.7.1
+  - 2.6.6
+  - 2.5.8
+  - 2.4.10
+  - jruby-head
 before_install: gem install bundler -v 2.0.2

data/CHANGELOG.md

@@ -1,3 +1,57 @@
+## [0.1.09] - 2020-06-06
+- Supports frames from "The Reasoned Scheme" book up to frame [1:76]
+
+### CHANGED
+- Method `FreshEnv#initialize`accepts an array of goals as second argument. This array is transformed into a conjunction of goals.
+- Method `RunStarExpression#initialize` accepts multiple multiple variable names and goals.
+- Method `RunStarExpression#run` can handle solutions with multiple variables.
+
+## [0.1.08] - 2020-05-30
+- Fix of nasty bug (object aliasing) that caused flaky failures in specs.
+
+### FIXED
+- `DuckFiber#resume` each call returns a distinct `Outcome` instance when successful.
+
+## [0.1.07] - 2020-05-23
+- Implementation of `disj2` (two arguments disjunction - or -)
+
+### New
+- Class `Disj2` as subclass of `GoalRelation` that implements the disjunction of two subgoals
+
+### CHANGED
+- Class `Disj2`: common code with `Conj2` class factored out to superclass `GoalRelation`
+- File `cons_cell.rb`: prevent multiple inclusions via different requires
+- Method `Vocabulary#ancestor_walker` now returns an `Enumerator` instead of a `Fiber`.
+
+### FIXED
+- Method `RunStarExpression#run` clear associations and rankings for second and consecutive solmutions
+
+
+## [0.1.06] - 2020-05-20
+- Implementation of `conj2` (two arguments conjunction - and -)
+
+### New
+- Class `CompositeGoal`
+- Class `Conj2` as subclass of `GoalRelation` that implements the conjunction of two subgoals
+- Mixin module `Designation` to factor out the common methods in `Variable` and `VariableRef` classes
+- Class `GoalArg` abstract class, that is a generalization for anything that be be argument of a goal.
+- Class `GoalRelation` as subclass of `Relation`. A goal that is linked to a such relation may have goals as its arguments only.
+
+### Changed
+- Class `Goal` is new subclass of class `GoalArg`. Therefore a goal can be an argument to another goal.
+- Class `Term` is new subclass of class `GoalArg`. Therefore a term can be an argument of a goal.
+- Classes `Variable`, `VariableRef` now include mix-in module `Designation`
+- File `cd_implementation.txt` Updated with changes of class relationship
+
+## [0.1.05] - 2020-05-09
+- Changed implementation of fused variables  
+- Magic comments for frozen string literal
+- Code re-styling to please Rubocop 0.82
+
+### Changed
+- File `README.md` Added "What is mini_kraken" text.
+- File `README.md` Added badges (CI Travis build status, Gem version, license)
+
 ## [0.1.04] - 2020-05-02
 ### Changed
 - File `README.md` Added "What is mini_kraken" text.

data/Gemfile

@@ -1,4 +1,6 @@
-source "https://rubygems.org"
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
 
 # Specify your gem's dependencies in mini_kraken.gemspec
 gemspec

data/README.md

@@ -11,14 +11,16 @@ Daniel P. Friedman, William E. Byrd, Oleg Kiselyov, and Jason Hemann: "The Reaso
 ISBN: 9780262535519, (2018), MIT Press.
 
 ### Features
-[X] ==  
-[X] run\*  
-[X] fresh  
+- [X] ==  
+- [X] run\*  
+- [X] fresh 
+- [X] conj2  
+- [X] disj2  
 
 ### TODO
-[-] disj2  
-[-] conj2  
-[-] conde  
+- [ ] defrel 
+- [ ] conde  
+- [ ] Occurs check
 
 ## Installation
 

data/Rakefile

@@ -1,6 +1,8 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec

data/lib/mini_kraken.rb

@@ -1,4 +1,6 @@
-require "mini_kraken/version"
+# frozen_string_literal: true
+
+require 'mini_kraken/version'
 
 module MiniKraken
   class Error < StandardError; end

data/lib/mini_kraken/core/any_value.rb

@@ -1,31 +1,33 @@
+# frozen_string_literal: true
+
 module MiniKraken
   module Core
     class AnyValue
       attr_reader :rank
-      
+
       # @param aName [String]
       # @param anEnv [Vocabulary]
       def initialize(aName, anEnv, alternate_names = [])
         @rank = anEnv.get_rank(aName, alternate_names)
       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
     end # class
   end # module
-end # module
+end # module

data/lib/mini_kraken/core/association.rb

@@ -1,21 +1,34 @@
+# frozen_string_literal: true
+
 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 [String] internal name of variable being associated the value.
+      attr_accessor :i_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
+        a_name = aVariable.respond_to?(:name) ? aVariable.i_name : aVariable
+        @i_name = validated_name(a_name)
         @value = aValue
       end
-      
+
+      private
+
+      def validated_name(aName)
+        raise StandardError, 'Name cannot be nil' if aName.nil?
+
+        cleaned = aName.strip
+        raise StandardError, 'Name cannot be empty or consists of spaces' if cleaned.empty?
+
+        cleaned
+      end
     end # class
   end # module
 end # module

data/lib/mini_kraken/core/association_walker.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'set'
 require_relative 'atomic_term'
 require_relative 'composite_term'
@@ -23,6 +25,7 @@ module MiniKraken
       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
 
@@ -43,6 +46,7 @@ module MiniKraken
 
       def walk_value(aTerm, anEnv)
         return aTerm if aTerm.kind_of?(AtomicTerm) || aTerm.kind_of?(AnyValue)
+
         result = nil
 
         if aTerm.kind_of?(CompositeTerm)
@@ -176,4 +180,4 @@ module MiniKraken
       end
     end # class
   end # module
-end # module
+end # module

data/lib/mini_kraken/core/atomic_term.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'term'
 require_relative 'freshness'
 
@@ -22,14 +24,14 @@ module MiniKraken
       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      
+      end
 
       # An atomic term is a ground term: by definition it doesn't contain
       # any fresh variable.
@@ -61,4 +63,4 @@ module MiniKraken
       end
     end # class
   end # module
-end # module
+end # module

data/lib/mini_kraken/core/binary_relation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'relation'
 require_relative 'composite_term'
 
@@ -5,20 +7,20 @@ module MiniKraken
   module Core
     class BinaryRelation < Relation
       # @param aName [String] Name of the relation.
-      # @param alternateName [String, NilClass] Alternative name (optional).    
+      # @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     |
@@ -55,7 +57,7 @@ module MiniKraken
         else
           [arg1, arg2]
         end
-      end      
+      end
     end # class
   end # module
-end # module
+end # module

data/lib/mini_kraken/core/composite_goal.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'environment'
+
+module MiniKraken
+  module Core
+    class CompositeGoal
+      # @return [Operator] The operator corresponding to this goal
+      attr_reader :operator
+
+      # @return [Array<Goal>] The child goals (sub-goals)
+      attr_reader :children
+
+      # @param anOperator [Operator] The operator corresponding to this goal
+      # @param theChildren [Array<Goal>] The child goals (sub-goals)
+      def initialize(anOperator, theChildren)
+        @operator = anOperator
+        @children = validated_children(theChildren)
+      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)
+        operator.solver_for(children, anEnv)
+      end
+
+      private
+
+      def validated_children(theChildren)
+        my_arity = operator.arity
+        if args.size != my_arity
+          err_msg = "Goal has #{theChildren.size} arguments, expected #{my_arity}"
+          raise StandardError, err_msg
+        end
+
+        prefix = 'Invalid goal argument '
+        theChildren.each do |subg|
+          raise StandardError, prefix + subg.to_s unless subg.kind_of?(Goal)
+        end
+
+        theChildren.dup
+      end
+    end # class
+  end # module
+end # module

data/lib/mini_kraken/core/composite_term.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'term'
 require_relative 'freshness'
 
@@ -6,17 +8,18 @@ module MiniKraken
     # An composite term is an Minikraken term that can be
     # decomposed into simpler MiniKraken data value(s).
     class CompositeTerm < Term
-
+      # Abstract method (to override). Return the child terms.
+      # @return [Array<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 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]      
+      # @return [Freshness]
       def freshness(_env)
          env.freshness_composite(self)
       end
@@ -33,22 +36,6 @@ module MiniKraken
           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
+end # module

data/lib/mini_kraken/core/conj2.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require_relative 'duck_fiber'
+require_relative 'goal'
+require_relative 'goal_relation'
+require_relative 'outcome'
+
+unless MiniKraken::Core.constants(false).include? :Conj2
+  module MiniKraken
+    module Core
+      # The conjunction is a relation that accepts only goal(s) as its two
+      # arguments. It succeeds if and only both its goal arguments succeeds.
+      class Conj2 < GoalRelation
+        include Singleton
+
+        def initialize
+          super('conj2', nil)
+        end
+
+        # @param actuals [Array<Term>] A two-elements array
+        # @param anEnv [Vocabulary] A vocabulary object
+        # @return [Fiber<Outcome>] A Fiber that yields Outcomes objects
+        def solver_for(actuals, anEnv)
+          g1, g2 = *validated_args(actuals)
+          Fiber.new { conjunction(g1, g2, anEnv) }
+        end
+
+        # Yields [Outcome, NilClass] result of the conjunction
+        # @param g1 [Goal] First goal argument
+        # @param g2 [Goal] Second goal argument
+        # @param voc [Vocabulary] A vocabulary object
+        def conjunction(g1, g2, voc)
+          if g1.relation.kind_of?(Fail) || g2.relation.kind_of?(Fail)
+            Fiber.yield Outcome.new(:"#u", voc)
+          else
+            outcome1 = nil
+            outcome2 = nil
+            f1 = g1.attain(voc)
+            loop do
+              outcome1 = f1.resume
+              break unless outcome1
+
+              outcome1.parent = voc unless outcome1.parent
+              if outcome1.successful?
+                f2 = g2.attain(outcome1)
+                loop do
+                  outcome2 = f2.resume
+                  break unless outcome2
+
+                  outcome2.parent = voc unless outcome2.parent
+                  if outcome2.successful?
+                    res = Outcome.new(:"#s", voc)
+                    res.merge(outcome1)
+                    res.merge(outcome2)
+                    Fiber.yield res
+                  else
+                    Fiber.yield outcome2
+                  end
+                  outcome2.clear
+                end
+              else
+                Fiber.yield outcome1
+              end
+              voc.clear if outcome1&.successful? && outcome2&.successful?
+            end
+          end
+
+          Fiber.yield nil
+        end
+      end # class
+
+      Conj2.instance.freeze
+    end # module
+  end # module
+end # unless