mini_kraken 0.1.05 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4ce5f0f43f5e84f377cf90e2ed49d6ff54de93b66641655fb41dd6b8feef277
-  data.tar.gz: 2081e486f8beba0b0073461464c632fa63af83cec27a48fb3d84c1a972b821f9
+  metadata.gz: ec7b984a9f0c857f74c8a8989c5da2072398775573b7ca6679d99f96ef13eac1
+  data.tar.gz: cdebdebae82c424b9ae701f959765f0905322798a371e2aec42ed9a229e35a4f
 SHA512:
-  metadata.gz: ea0580c9219f1a1fd586d024f06e11cf6dd1f979182c6f5a15473c65b78fa7244ba01ca9191f31e73de78b20d7aa88c60d86afa1207dbaab246c64c6650f0d1f
-  data.tar.gz: 9af43ee21606cac23d2512002491d0264fcbc7a74b9974edbd70c23f4bcbf25c7cc7010845aad88dee2d507a1f6d070dd402cd9a6f2abe0234999617b3ae7b68
+  metadata.gz: 2ce3553527adeebef7adc69ec5a861fe65f9f451e54a81e23f00769923ced6b6a6011846ae3e9a673c8b9094a7dcce6ea6f8d263d55c8f543ef0de309e34c11c
+  data.tar.gz: 90b45061cde1119ad648359063682f411f9e5705a294340976bd027561b1d94da7afbfc9d0d27dce67942e1407d4d4ea40df85cf3fe67c9fca998d22052b6187

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,59 @@
+## [0.1.10] - 2020-06-10
+- Supports frames from "The Reasoned Scheme" book up to frame [1:81]
+
+### New
+- Factory methods `Outcome#failure`, `Outcome#success`
+- Method `Vocabulary#inspect`
+- File `outcome_spec.rb`
+
+### FIXED
+- `Conj2#conjunction` vocabulary wasn't cleared when outcome2 was nil.
+
+## [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

data/README.md

@@ -13,12 +13,14 @@ ISBN: 9780262535519, (2018), MIT Press.
 ### Features
 - [X] ==  
 - [X] run\*  
-- [X] fresh  
+- [X] fresh 
+- [X] conj2  
+- [X] disj2  
 
 ### TODO
-- [ ] disj2  
-- [ ] conj2  
+- [ ] defrel 
 - [ ] conde  
+- [ ] Occurs check
 
 ## Installation
 

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

@@ -8,6 +8,8 @@ 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

data/lib/mini_kraken/core/conj2.rb

@@ -0,0 +1,79 @@
+# 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)
+          # require 'debug'
+          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
+              if outcome1.successful? && (outcome2&.successful? || outcome2.nil?)
+                voc.clear
+              end
+            end
+          end
+
+          Fiber.yield nil
+        end
+      end # class
+
+      Conj2.instance.freeze
+    end # module
+  end # module
+end # unless

data/lib/mini_kraken/core/cons_cell.rb

@@ -2,47 +2,53 @@
 
 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
+unless MiniKraken::Core.constants(false).include? :ConsCell
+  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
+
+        def append(another)
+          @cdr = another
+        end
+      end # class
+
+      # Constant representing the null (empty) list.
+      NullList = ConsCell.new(nil, nil).freeze
+    end # module
   end # module
-end # module
+end # defined

data/lib/mini_kraken/core/designation.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module MiniKraken
+  module Core
+    # Wordnet definition: Identifying word or words by which someone or
+    # something is called and classified or distinguished from others.
+    # Mix-in module that contains factored code for managing named entries
+    # in a vocabulary such as variables and variable references.
+    module Designation
+      # @return [String] User-defined name of the variable
+      attr_reader :name
+
+      def init_designation(aName)
+        @name = valid_name(aName)
+      end
+
+      # @param voc [Vocabulary]
+      # @return [Freshness]
+      def freshness(voc)
+        voc.freshness_ref(self)
+      end
+
+      # @param voc [Vocabulary]
+      # @return [Boolean]
+      def fresh?(voc)
+        frsh = freshness(voc)
+        frsh.degree == :fresh || frsh.degree == :bound
+      end
+
+      # @param voc [Vocabulary]
+      # @return [Boolean]
+      def bound?(voc)
+        frsh = freshness(voc)
+        frsh.degree == :bound
+      end
+
+      # @param voc [Vocabulary]
+      # @return [Boolean]
+      def ground?(voc)
+        frsh = freshness(voc)
+        frsh.degree == :bound
+      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/disj2.rb

@@ -0,0 +1,71 @@
+# 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? :Disj2
+  module MiniKraken
+    module Core
+      # The disjunction is a relation that accepts only goal(s) as its two
+      # arguments. It succeeds if at least one of its goal arguments succeeds.
+      class Disj2 < GoalRelation
+        include Singleton
+
+        def initialize
+          super('disj2', 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 { disjunction(g1, g2, anEnv) }
+        end
+
+        # Yields [Outcome, NilClass] result of the disjunction
+        # @param g1 [Goal] First goal argument
+        # @param g2 [Goal] Second goal argument
+        # @param voc [Vocabulary] A vocabulary object
+        def disjunction(g1, g2, voc)
+          # require 'debug'
+          outcome1 = nil
+          outcome2 = nil
+          if g1.relation.kind_of?(Fail) && g2.relation.kind_of?(Fail)
+            Fiber.yield Outcome.new(:"#u", voc)
+          else
+            f1 = g1.attain(voc)
+            loop do
+              outcome1 = f1.resume
+              break unless outcome1
+
+              outcome1.parent = voc unless outcome1.parent
+              if outcome1.successful?
+                Fiber.yield outcome1
+                outcome1.clear
+              end
+            end
+            f2 = g2.attain(voc)
+            loop do
+              outcome2 = f2.resume
+              break unless outcome2
+
+              outcome2.parent = voc unless outcome2.parent
+              if outcome2.successful?
+                Fiber.yield outcome2
+                outcome2.clear
+              end
+            end
+          end
+
+          Fiber.yield nil
+        end
+      end # class
+
+      Disj2.instance.freeze
+    end # module
+  end # module
+end # unless