mini_kraken 0.2.00 → 0.2.01

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4bbfe3d58d4c7271a5c8a54486a743c51d6fddcb3b068095cad44cacad575c83
-  data.tar.gz: 012b412a95752592b5be70859e00d94b379e2c4c564d37d932a300a03cbc9716
+  metadata.gz: f51855ac3179a111a4ace328340402fa167818773086076abf90ed845c31d248
+  data.tar.gz: f6bde0d3d7b872461d7cb0b087eaab821240f14317445e95f4d832d09af51e2f
 SHA512:
-  metadata.gz: 952d93b01de392c7168e7cfb4a3cc911e4d1b53be11a4a10d67012bb4ab4a8f69aa42f41bf13a756f89a6d09eb775a5594174d73334c57c2230039b7991e89fd
-  data.tar.gz: a60adbd5da627495badab63de355336f131a5e599c40226931366a7c1b4a349b2542ccb55cf30ef8e60990341c1f5d8547804b1552fbbbc504bd1bed40a36d9e
+  metadata.gz: ae6319164a2f6212bdbdea35dd5b5befa86648b685063dea79d220b70e5852c3e8b343d2d37ebfe6584aa3966b44174e91df2866d63e03a219a0008a5b382d66
+  data.tar.gz: 70eb204ab842ea45527bd5ca8661dcd98081422cae4d6848d220bc70e080da94b3b7078f3602f1143535821a9894309b9bec39ec5f4d6c60edcfd21cfa5c8f4f

data/.rubocop.yml

@@ -0,0 +1,334 @@
+AllCops:
+  Exclude:
+    - 'exp/**/*'
+
+Layout/ArgumentAlignment:
+  Enabled: false
+
+Layout/ArrayAlignment:
+  Enabled: true
+  EnforcedStyle: with_fixed_indentation
+
+Layout/CaseIndentation:
+  Enabled: false
+
+Layout/ClosingHeredocIndentation:
+  Enabled: false
+
+Layout/CommentIndentation:
+  Enabled: false
+
+Layout/ElseAlignment:
+  Enabled: false
+
+Layout/EmptyLines:
+  Enabled: false
+
+Layout/EndAlignment:
+  Enabled: false
+
+Layout/EndOfLine:
+  Enabled: true
+  EnforcedStyle: lf
+
+Layout/FirstArgumentIndentation:
+  Enabled: false
+
+Layout/IndentationWidth:
+  Enabled: false
+
+Layout/IndentationConsistency:
+  Enabled: true
+
+Layout/HeredocIndentation:
+  Enabled: false
+
+Layout/MultilineHashBraceLayout:
+  Enabled: true
+  
+Layout/MultilineMethodCallBraceLayout:
+  Enabled: true
+  EnforcedStyle: same_line  
+
+Layout/SpaceAroundOperators:
+  Enabled: true
+
+Layout/SpaceInsideParens:
+  Enabled: true
+
+Layout/IndentationStyle:
+  Enabled: true
+  
+Layout/SpaceAroundMethodCallOperator:
+  Enabled: true
+
+Layout/TrailingEmptyLines:
+  Enabled: true
+
+Layout/TrailingWhitespace:
+  Enabled: true
+
+Lint/Loop:
+  Enabled: true
+  
+Lint/RaiseException:
+  Enabled: true
+
+Lint/RescueException:
+  Enabled: true
+  
+Lint/StructNewOverride:
+  Enabled: true
+
+Lint/UnusedMethodArgument:
+  Enabled: true
+
+Lint/UselessAccessModifier:
+  Enabled: true
+
+Lint/Void:
+  Enabled: false
+
+Lint/UselessAssignment:
+  Enabled: true
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: true
+  Max: 350
+  
+Metrics/BlockNesting:
+  Enabled: true
+  Max: 5
+
+Metrics/ClassLength:
+  Enabled: true
+  Max: 350
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Layout/LineLength:
+  Enabled: false
+  Max: 90
+
+Metrics/MethodLength:
+  Enabled: true
+  Max: 50
+
+Metrics/ModuleLength:
+  Enabled: true
+  Max: 500
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Naming/ConstantName:
+  Enabled: false
+
+Naming/ClassAndModuleCamelCase:
+  Enabled: false
+
+Naming/BlockParameterName:
+  Enabled: true
+
+Naming/MethodParameterName:
+  Enabled: false
+
+Naming/VariableName:
+  Enabled: false
+
+Style/Alias:
+  Enabled: true
+
+Layout/HashAlignment:
+  Enabled: false
+
+Style/AsciiComments:
+  Enabled: false
+
+Style/BarePercentLiterals:
+  Enabled: false
+
+Style/BlockComments:
+  Enabled: false
+
+Style/CharacterLiteral:
+  Enabled: false
+
+Style/ClassCheck:
+  Enabled: false
+
+Style/ClassVars:
+  Enabled: false
+
+Style/ColonMethodCall:
+  Enabled: false
+
+Style/CommentAnnotation:
+  Enabled: false
+
+Style/CommentedKeyword:
+  Enabled: false
+
+Style/ConditionalAssignment:
+  Enabled: false
+
+Style/DefWithParentheses:
+  Enabled: true
+
+Style/Documentation:
+  Enabled: false
+
+Style/ExpandPathArguments:
+  Enabled: false
+  
+Style/ExponentialNotation:
+  Enabled: true
+
+Style/GuardClause:
+  Enabled: false
+  
+Style/HashEachMethods:
+  Enabled: true
+  
+Style/HashTransformKeys:
+  Enabled: true
+  
+Style/HashTransformValues:
+  Enabled: true
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/InverseMethods:
+  Enabled: true
+  
+Style/MissingRespondToMissing:  
+  Enabled: false
+
+Style/Next:
+  Enabled: false
+
+Style/NumericLiterals:
+  Enabled: false
+
+Style/RaiseArgs:
+  Enabled: true
+
+Style/RedundantReturn:
+  Enabled: false
+
+Style/RedundantSelf:
+  Enabled: true
+
+Style/RegexpLiteral:
+  Enabled: false
+
+Style/PercentLiteralDelimiters:
+  Enabled: false
+
+Style/StderrPuts:
+  Enabled: false
+
+Style/StringLiterals:
+  Enabled: true
+
+Style/TernaryParentheses:
+  Enabled: false
+
+Style/UnlessElse:
+  Enabled: false
+  
+# Rubocop complains when it doesn't find an explicit setting for the following cops:
+Layout/EmptyLinesAroundAttributeAccessor:
+  Enabled: true
+
+Lint/BinaryOperatorWithIdenticalOperands:
+  Enabled: true
+
+Lint/DeprecatedOpenSSLConstant:
+  Enabled: true
+
+Lint/DuplicateElsifCondition:
+  Enabled: true
+
+Lint/DuplicateRescueException:
+  Enabled: true
+
+Lint/EmptyConditionalBody:
+  Enabled: true
+
+Lint/FloatComparison:
+  Enabled: true
+
+Lint/MissingSuper:
+  Enabled: true
+
+Lint/MixedRegexpCaptureTypes:
+  Enabled: true
+
+Lint/OutOfRangeRegexpRef:
+  Enabled: true
+
+Lint/SelfAssignment:
+  Enabled: true
+
+Lint/TopLevelReturnWithArgument:
+  Enabled: true
+
+Lint/UnreachableLoop:
+  Enabled: true
+
+Style/AccessorGrouping:
+  Enabled: true
+
+Style/ArrayCoercion:
+  Enabled: true
+
+Style/BisectedAttrAccessor:
+  Enabled: true
+
+Style/CaseLikeIf:
+  Enabled: true
+
+Style/ExplicitBlockArgument:
+  Enabled: true
+
+Style/GlobalStdStream:
+  Enabled: true
+
+Style/HashAsLastArrayItem:
+  Enabled: true
+
+Style/HashLikeCase:
+  Enabled: true
+
+Style/OptionalBooleanParameter:
+  Enabled: true
+
+Style/RedundantAssignment:
+  Enabled: true
+
+Style/RedundantFetchBlock:
+  Enabled: true
+
+Style/RedundantFileExtensionInRequire:
+  Enabled: true
+
+Style/RedundantRegexpCharacterClass:
+  Enabled: true
+
+Style/RedundantRegexpEscape:
+  Enabled: true
+
+Style/SingleArgumentDig:
+  Enabled: true
+
+Style/SlicingWithRange:
+  Enabled: true
+
+Style/StringConcatenation:
+  Enabled: true

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [0.2.01] - 2020-08-07
+- The DSL (Domain Specific Language) now supports `defrel` and boolean literals.
+
+### CHANGED
+- Constructor `DefRelation#initialize` now freezes any new class instance.  
+- Constructor `GoalTemplate#initialize` now freezes any new class instance.  
+- Mixin module `Core::DSL` new method `defrel` to build custom relations.
+- File `.rubocop.yml` to please Rubocop 0.89
+
 ## [0.2.00] - 2020-07-12
 - First release of DSL (Domain Specific Language)
 - Fix defect for fused variables that remain fresh

data/README.md

@@ -30,12 +30,12 @@ ISBN: 9780262535519, (2018), MIT Press.
 - [ ] Occurs check
 
 List-centric relations from Chapter 2
-- [ ] caro
-- [ ] cdro
-- [ ] conso
-- [ ] nullo
-- [ ] pairo
-- [ ] singletono
+- [ ] caro  
+- [ ] cdro  
+- [ ] conso  
+- [ ] nullo  
+- [ ] pairo  
+- [ ] singletono  
 
 ## Installation
 
@@ -73,9 +73,9 @@ The two first lines in the above code snippet are pretty standard:
 - The first line loads the `mini_kraken` library.
 - The second line add the DSL methods to the current object.
 
-The next line constitutes a trivial `miniKanren` program.
-The aim of a `miniKanren` program is to find one or more solutions involving provided variable(s)
-and satisfying one or more goals.
+The next line constitutes a trivial `miniKanren` program.  
+The aim of a `miniKanren` program is to find one or more solutions involving the given logical variable(s)
+and satisfying one or more goals to the `run_star method.  
 In our example, the `run_star` method instructs `MiniKraken` to find all solutions,  
 knowing that each successful solution:
 - binds a value to the provided variable `q` and
@@ -101,7 +101,8 @@ So the above program succeeds and the only found solution is obtained by binding
  puts result # => ()
  ```
 In this example, we learn that `run_star` can take multiple goals placed in an array.
-The program fails to find a solution since it is not possible to satisfy the two `equals` goals simultaneously. In that case, the `run_star` return an empty list represented as `()` in the output.
+The program fails to find a solution since it is not possible to satisfy the two `equals` goals simultaneously.  
+In case of failure, the `run_star` returns an empty list represented as `()` in the output.
 
 
 ### Example 3
@@ -127,7 +128,8 @@ This time, `run_star` takes two logical variables -`x` and `y`- and successfully
  puts result # => ((:blue :sea) (:blue :mountain) (:red :sea) (:red :mountain))
  ```
 
- Here, `run_star` takes two logical variables and two `disj2` goals. A `disj2` succeeds if any of its arguments succeeds.
+ Here, `run_star` takes two logical variables and two `disj2` goals.  
+ A `disj2` succeeds if any of its arguments succeeds.  
  This program finds four distinct solutions for x, y pairs.
 
 ## Development

data/lib/mini_kraken/core/atomic_term.rb

@@ -13,6 +13,7 @@ module MiniKraken
 
       # @param aValue [Object] Ruby representation of MiniKraken data value
       def initialize(aValue)
+        super()
         @value = aValue
         @value.freeze
       end

data/lib/mini_kraken/core/cons_cell.rb

@@ -10,6 +10,7 @@ unless MiniKraken::Core.constants(false).include? :ConsCell
         attr_reader :cdr
 
         def initialize(obj1, obj2 = nil)
+          super()
           @car = obj1
           if obj2.kind_of?(ConsCell) && obj2.null?
             @cdr = nil

data/lib/mini_kraken/core/def_relation.rb

@@ -19,6 +19,7 @@ module MiniKraken
         super(aName, alternateName)
         @formals = validated_formals(theFormals)
         @goal_template = validated_goal_template(aGoalTemplate)
+        freeze
       end
 
       # Number of arguments for the relation.

data/lib/mini_kraken/core/environment.rb

@@ -60,7 +60,7 @@ module MiniKraken
         return unless descendent.successful?
 
         vars.each_key do |var_name|
-          assocs = descendent[var_name]
+          # assocs = descendent[var_name]
           move_assocs(var_name, descendent)
         end
       end

data/lib/mini_kraken/core/equals.rb

@@ -38,10 +38,7 @@ unless MiniKraken::Core.constants(false).include? :Equals
             return result
           end
           new_arg1, new_arg2 = commute_cond(arg1, arg2, anEnv)
-          result = do_unification(new_arg1, new_arg2, anEnv)
-          # anEnv.merge(result) if result.successful? && !result.association.empty?
-
-          result
+          do_unification(new_arg1, new_arg2, anEnv)
         end
 
         private
@@ -141,7 +138,7 @@ unless MiniKraken::Core.constants(false).include? :Equals
             total_success = subresults.all?(&:successful?)
             if total_success
               memo = Outcome.success(anEnv)
-              associations = subresults.reduce(memo) do |sub_total, outcome|
+              subresults.reduce(memo) do |sub_total, outcome|
                 sub_total.merge(outcome)
                 sub_total
               end

data/lib/mini_kraken/core/formal_ref.rb

@@ -11,6 +11,7 @@ module MiniKraken
       attr_reader :name
 
       def initialize(aName)
+        super()
         @name = validated_name(aName)
       end
 

data/lib/mini_kraken/core/goal.rb

@@ -16,6 +16,7 @@ module MiniKraken
       # @param aRelation [Relation] The relation corresponding to this goal
       # @param args [Array<Term>] The actual aguments of the goal
       def initialize(aRelation, args)
+        super()
         @relation = aRelation
         @actuals = validated_actuals(args)
       end
@@ -35,7 +36,7 @@ module MiniKraken
           raise StandardError, err_msg
         end
 
-        prefix = "Invalid goal argument '"
+        prefix = 'Invalid goal argument'
         args.each do |actual|
           if actual.kind_of?(GoalArg) || actual.kind_of?(Environment)
             next
@@ -43,7 +44,7 @@ module MiniKraken
             validated_actuals(actual)
           else
             actual_display = actual.nil? ? 'nil' : actual.to_s
-            raise StandardError, prefix + actual_display + "'"
+            raise StandardError, "#{prefix} '#{actual_display}'"
           end
         end
 

data/lib/mini_kraken/core/goal_template.rb

@@ -8,15 +8,17 @@ module MiniKraken
     # The individual goals are instantiated when the formal arguments
     # are bound to goal arguments
     class GoalTemplate < BaseArg
-      # @return [Array<BaseArg>}] Arguments of goal template.
+      # @return [Array<BaseArg>] Arguments of goal template.
       attr_reader :args
 
       # @return [Relation] Main relation for the goal template
       attr_reader :relation
 
       def initialize(aRelation, theArgs)
+        super()
         @relation = validated_relation(aRelation)
         @args = validated_args(theArgs)
+        freeze
       end
 
       # @param formals [Array<FormalArg>] Array of formal arguments

data/lib/mini_kraken/core/k_symbol.rb

@@ -20,7 +20,7 @@ module MiniKraken
 
       # Returns a string representing the MiniKraken symbol.
       def to_s
-        ':' + id2name
+        ":#{id2name}"
       end
     end # class
   end # module

data/lib/mini_kraken/core/variable_ref.rb

@@ -13,6 +13,7 @@ module MiniKraken
 
       # @param aName [String] The name of the variable
       def initialize(aName)
+        super()
         init_designation(aName)
       end
 

data/lib/mini_kraken/glue/dsl.rb

@@ -1,11 +1,17 @@
 # frozen_string_literal: true
 
+require 'set'
 require_relative '../core/any_value'
 require_relative '../core/conj2'
 require_relative '../core/cons_cell'
+require_relative '../core/def_relation'
 require_relative '../core/disj2'
 require_relative '../core/equals'
 require_relative '../core/fail'
+require_relative '../core/formal_arg'
+require_relative '../core/formal_ref'
+require_relative '../core/goal_template'
+require_relative '../core/k_boolean'
 require_relative '../core/k_symbol'
 require_relative '../core/succeed'
 require_relative '../core/variable_ref'
@@ -15,31 +21,64 @@ require_relative 'run_star_expression'
 
 module MiniKraken
   module Glue
+    # The mixin module that implements the methods for the DSL
+    # (DSL = Domain Specific Langague) that allows MiniKraken
+    # users to embed Minikanren in their Ruby code.
     module DSL
+      # A run* expression tries to find all the solutions
+      # that meet the given goal.
       # @return [Core::ConsCell] A list of solutions
       def run_star(var_names, goal)
         program = RunStarExpression.new(var_names, goal)
         program.run
       end
 
+      # conj2 stands for conjunction of two arguments.
+      # Returns a goal linked to the Core::Conj2 relation.
+      # The rule of that relation succeeds when both arguments succeed.
+      # @param arg1 [Core::Goal]
+      # @param arg2 [Core::Goal]
+      # @return [Core::Failure|Core::Success]
       def conj2(arg1, arg2)
-        Core::Goal.new(Core::Conj2.instance, [convert(arg1), convert(arg2)])
+       goal_class.new(Core::Conj2.instance, [convert(arg1), convert(arg2)])
       end
 
       def cons(car_item, cdr_item = nil)
-        Core::ConsCell.new(convert(car_item), convert(cdr_item))
+        tail = cdr_item.nil? ? cdr_item : convert(cdr_item)
+        Core::ConsCell.new(convert(car_item), tail)
+      end
+
+      def defrel(relationName, theFormals, &aGoalTemplateExpr)
+        start_defrel
+
+        case theFormals
+          when String
+            @defrel_formals << theFormals
+          when Array
+            @defrel_formals.merge(theFormals)
+        end
+
+        formals = @defrel_formals.map { |name| Core::FormalArg.new(name) }
+        g_template = aGoalTemplateExpr.call
+        result = Core::DefRelation.new(relationName, g_template, formals)
+        add_defrel(result)
+
+        end_defrel
+        result
       end
 
       def disj2(arg1, arg2)
-        Core::Goal.new(Core::Disj2.instance, [convert(arg1), convert(arg2)])
+        goal_class.new(Core::Disj2.instance, [convert(arg1), convert(arg2)])
       end
 
+      # @return [Core::Fail] A goal that unconditionally fails.
       def _fail
-        Core::Goal.new(Core::Fail.instance, [])
+        goal_class.new(Core::Fail.instance, [])
       end
 
       def equals(arg1, arg2)
-        Core::Goal.new(Core::Equals.instance, [convert(arg1), convert(arg2)])
+        # require 'debug'
+        goal_class.new(Core::Equals.instance, [convert(arg1), convert(arg2)])
       end
 
       def fresh(var_names, goal)
@@ -47,19 +86,30 @@ module MiniKraken
 
         if var_names.kind_of?(String) || var_names.kind_of?(Core::VariableRef)
           vars = [var_names]
-        elsif
-
+        else
           vars = var_names
         end
+
         FreshEnv.new(vars, goal)
       end
 
+      def list(*members)
+        return null if members.empty?
+
+        head = nil
+        members.reverse_each { |elem| head = Core::ConsCell.new(convert(elem), head) }
+
+        head
+      end
+
+      # @return [ConsCell] Returns an empty list, that is, a pair whose members are nil.
       def null
         Core::ConsCell.new(nil, nil)
       end
 
+      # @return [Core::Succeed] A goal that unconditionally succeeds.
       def succeed
-        Core::Goal.new(Core::Succeed.instance, [])
+        goal_class.new(Core::Succeed.instance, [])
       end
 
       private
@@ -74,27 +124,83 @@ module MiniKraken
               any_val = Core::AnyValue.allocate
               any_val.instance_variable_set(:@rank, rank)
               converted = any_val
+            elsif anArgument.id2name =~ /^"#[ft]"$/
+              converted = Core::KBoolean.new(anArgument)
             else
               converted = Core::KSymbol.new(anArgument)
             end
+          when String
+            if anArgument =~ /^#[ft]$/
+              converted = Core::KBoolean.new(anArgument)
+            else
+              msg = "Internal error: undefined conversion for #{anArgument.class}"
+              raise StandardError, msg
+            end
+          when false, true
+            converted = Core::KBoolean.new(anArgument)
+          when Core::KBoolean
+            converted = anArgument
+          when Core::FormalRef
+            converted = anArgument
           when Core::Goal
             converted = anArgument
+          when Core::GoalTemplate
+            converted = anArgument
           when Core::VariableRef
             converted = anArgument
           when Core::ConsCell
             converted = anArgument
+          else
+            msg = "Internal error: undefined conversion for #{anArgument.class}"
+            raise StandardError, msg
         end
 
         converted
       end
 
+      def default_mode
+        @dsl_mode = :default
+        @defrel_formals = nil
+      end
+
+      def goal_class
+        default_mode unless instance_variable_defined?(:@dsl_mode)
+        @dsl_mode == :default ? Core::Goal : Core::GoalTemplate
+      end
+
+      def start_defrel
+        @dsl_mode = :defrel
+        @defrel_formals = Set.new
+      end
+
+      def end_defrel
+        default_mode
+      end
+
+      def add_defrel(aDefRelation)
+        @defrels = {} unless instance_variable_defined?(:@defrels)
+        @defrels[aDefRelation.name] = aDefRelation
+      end
+
       def method_missing(mth, *args)
         result = nil
 
         begin
           result = super(mth, *args)
         rescue NameError
-          result = Core::VariableRef.new(mth.id2name)
+          name = mth.id2name
+          @defrels = {} unless instance_variable_defined?(:@defrels)
+          if @defrels.include?(name)
+            def_relation = @defrels[name]
+            result = Core::Goal.new(def_relation, args.map { |el| convert(el) })
+          else
+            default_mode unless instance_variable_defined?(:@dsl_mode)
+            if @dsl_mode == :defrel && @defrel_formals.include?(name)
+              result = Core::FormalRef.new(name)
+            else
+              result = Core::VariableRef.new(name)
+            end
+          end
         end
 
         result

data/lib/mini_kraken/glue/run_star_expression.rb

@@ -38,11 +38,9 @@ module MiniKraken
 
       # @return [Array] A vector of assignment for each variable
       def build_solution(outcome)
-        sol = env.vars.values.map do |var|
+        env.vars.values.map do |var|
           outcome.successful? ? var.quote(outcome) : nil
         end
-
-        sol
       end
 
       # Transform the solutions into sequence of conscells.

data/lib/mini_kraken/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MiniKraken
-  VERSION = '0.2.00'
+  VERSION = '0.2.01'
 end

data/mini_kraken.gemspec

@@ -9,6 +9,7 @@ module PkgExtending
   def self.pkg_files(aPackage)
     file_list = Dir[
       '.rspec',
+      '.rubocop.yml',
       '.travis.yml',
       'Gemfile',
       'Rakefile',
@@ -19,7 +20,8 @@ module PkgExtending
       'bin/*.rb',
       'lib/*.*',
       'lib/**/*.rb',
-      'spec/**/*.rb'
+      'spec/**/*.rb',
+      'spec/.rubocop.yml'
     ]
     aPackage.files = file_list
     aPackage.test_files = Dir['spec/**/*_spec.rb']
@@ -38,8 +40,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Dimitri Geshef']
   spec.email         = ['famished.tiger@yahoo.com']
 
-  spec.summary       = %q{Implementation of Minikanren language in Ruby. WIP}
-  spec.description   = %q{Implementation of Minikanren language in Ruby. WIP}
+  spec.summary       = 'Implementation of Minikanren language in Ruby. WIP'
+  spec.description   = 'Implementation of Minikanren language in Ruby. WIP'
   spec.homepage      = 'https://github.com/famished-tiger/mini_kraken'
   spec.license       = 'MIT'
 
@@ -47,6 +49,7 @@ Gem::Specification.new do |spec|
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
+  spec.required_ruby_version = '~> 2.4'
 
   PkgExtending.pkg_files(spec)
   PkgExtending.pkg_documentation(spec)

data/spec/.rubocop.yml

@@ -0,0 +1,13 @@
+inherit_from: ../.rubocop.yml
+
+# RSpec expectation lines can be very lenghty
+Layout/LineLength:
+  Max: 99
+
+# RSpec contexts can be very lenghty
+Metrics/BlockLength:
+  Max: 1000
+
+# RSpec modules can be very lenghty  
+Metrics/ModuleLength:
+  Max: 1000

data/spec/core/duck_fiber_spec.rb

@@ -52,7 +52,7 @@ module MiniKraken
           outcome1 = instance1.resume
 
           instance2 = DuckFiber.new(:success)
-          outcome2 = instance1.resume
+          outcome2 = instance2.resume
 
           expect(outcome1).not_to be_equal(outcome2)
         end

data/spec/core/k_symbol_spec.rb

@@ -65,7 +65,7 @@ module MiniKraken
           # Default Ruby representation, different value
           expect(subject == :pod).to be_falsy
         end
-        
+
         it 'should provide a string representation of itself' do
           expect(subject.to_s).to eq(':pea')
         end

data/spec/glue/dsl_chap1_spec.rb

@@ -68,7 +68,7 @@ module MiniKraken
           expect(result.car).to eq(:_0)
         end
 
-        it 'passes frame 1:21' do
+        it "supports 'fresh' and passes frame 1:21" do
           # Reasoned S2, frame 1:21
           # (run* q (fresh (x) (== 'pea q))) ;; => (pea)
 
@@ -176,7 +176,7 @@ module MiniKraken
           expect(result.car).to eq(cons(:_0, cons(:_1, cons(:_0))))
         end
 
-        it 'passes frame 1:50' do
+        it "supports 'conj2' relation and passes frame 1:50" do
           # Reasoned S2, frame 1:50
           # (run* q (conj2 succeed succeed)) ;; => (_0)
 
@@ -216,7 +216,7 @@ module MiniKraken
           expect(result.car).to eq(:corn)
         end
 
-        it 'passes frame 1:55' do
+        it "supports 'disj2' and passes frame 1:55" do
           # Reasoned S2, frame 1:55
           # (run* q (disj2 fail fail)) ;; => ()
 
@@ -301,7 +301,7 @@ module MiniKraken
           #               (== 'oil x))))) ;; => (olive _0 oil)
 
           result = run_star('x', disj2(conj2(equals(:virgin, x), _fail),
-                            disj2(equals(:olive, x), disj2(succeed, equals(:oil, x)))))
+            disj2(equals(:olive, x), disj2(succeed, equals(:oil, x)))))
           expect(result).to eq(cons(:olive, cons(:_0, cons(:oil))))
         end
 
@@ -317,8 +317,8 @@ module MiniKraken
           #             (== '(,x ,y) r)))))) ;; => ((split pea))
 
           result = run_star('r', fresh('x', fresh('y',
-            conj2(equals(:split, x), conj2(
-              equals(:pea, y), equals(cons(x, cons(y)), r))))))
+            conj2(equals(:split, x),
+            conj2(equals(:pea, y), equals(cons(x, cons(y)), r))))))
           expect(result).to eq(cons(cons(:split, cons(:pea))))
         end
 
@@ -396,8 +396,7 @@ module MiniKraken
           #     (== 'pea y))) ;; => ((split pea))
 
           result = run_star(%w[x y], conj2(equals(:split, x), equals(:pea, y)))
-          expect(result.car.car).to eq(:split)
-          expect(result.car.cdr.car).to eq(:pea)
+          expect(result.car).to eq(list(:split, :pea))
         end
 
         it 'passes frame 1:76' do
@@ -410,10 +409,8 @@ module MiniKraken
           result = run_star(%w[x y], disj2(
             conj2(equals(:split, x), equals(:pea, y)),
             conj2(equals(:red, x), equals(:bean, y))))
-          expect(result.car.car).to eq(:split)
-          expect(result.car.cdr.car).to eq(:pea)
-          expect(result.cdr.car.car).to eq(:red)
-          expect(result.cdr.car.cdr.car).to eq(:bean)
+          expect(result.car).to eq(list(:split, :pea))
+          expect(result.cdr.car).to eq(list(:red, :bean))
         end
 
         it 'passes frame 1:77' do
@@ -432,12 +429,8 @@ module MiniKraken
                 conj2(equals(:split, x), equals(:pea, y)),
                 conj2(equals(:red, x), equals(:bean, y))),
               equals(cons(x, cons(y, cons(:soup))), r))))
-          expect(result.car.car).to eq(:split)
-          expect(result.car.cdr.car).to eq(:pea)
-          expect(result.car.cdr.cdr.car).to eq(:soup)
-          expect(result.cdr.car.car).to eq(:red)
-          expect(result.cdr.car.cdr.car).to eq(:bean)
-          expect(result.cdr.car.cdr.cdr.car).to eq(:soup)
+          expect(result.car).to eq(list(:split, :pea, :soup))
+          expect(result.cdr.car).to eq(list(:red, :bean, :soup))
         end
 
         it 'passes frame 1:78' do
@@ -451,15 +444,11 @@ module MiniKraken
 
           result = run_star('r',
             fresh(%w[x y], [disj2(
-                conj2(equals(:split, x), equals(:pea, y)),
-                conj2(equals(:red, x), equals(:bean, y))),
+              conj2(equals(:split, x), equals(:pea, y)),
+              conj2(equals(:red, x), equals(:bean, y))),
               equals(cons(x, cons(y, cons(:soup))), r)]))
-          expect(result.car.car).to eq(:split)
-          expect(result.car.cdr.car).to eq(:pea)
-          expect(result.car.cdr.cdr.car).to eq(:soup)
-          expect(result.cdr.car.car).to eq(:red)
-          expect(result.cdr.car.cdr.car).to eq(:bean)
-          expect(result.cdr.car.cdr.cdr.car).to eq(:soup)
+          expect(result.car).to eq(list(:split, :pea, :soup))
+          expect(result.cdr.car).to eq(list(:red, :bean, :soup))
         end
 
         it 'passes frame 1:80' do
@@ -471,15 +460,11 @@ module MiniKraken
           #   (== 'soup z)) ;; => ((split pea soup) (red bean soup))
 
           result = run_star(%w[x y z], [disj2(
-                conj2(equals(:split, x), equals(:pea, y)),
-                conj2(equals(:red, x), equals(:bean, y))),
-              equals(:soup, z)])
-          expect(result.car.car).to eq(:split)
-          expect(result.car.cdr.car).to eq(:pea)
-          expect(result.car.cdr.cdr.car).to eq(:soup)
-          expect(result.cdr.car.car).to eq(:red)
-          expect(result.cdr.car.cdr.car).to eq(:bean)
-          expect(result.cdr.car.cdr.cdr.car).to eq(:soup)
+            conj2(equals(:split, x), equals(:pea, y)),
+            conj2(equals(:red, x), equals(:bean, y))),
+            equals(:soup, z)])
+          expect(result.car).to eq(list(:split, :pea, :soup))
+          expect(result.cdr.car).to eq(list(:red, :bean, :soup))
         end
 
         it 'passes frame 1:81' do
@@ -489,8 +474,119 @@ module MiniKraken
           #   (== 'pea y)) ;; => ((split pea))
 
           result = run_star(%w[x y], [equals(:split, x), equals(:pea, y)])
-          expect(result.car.car).to eq(:split)
-          expect(result.car.cdr.car).to eq(:pea)
+          expect(result.car).to eq(list(:split, :pea))
+        end
+
+        it "supports 'defrel' and passes frame 1:82" do
+          # Reasoned S2, frame 1:82
+          # (defrel (teacupo t)
+          #   (disj2 (== 'tea t) (== 'cup t)))
+
+          result = defrel('teacupo', 't') do
+            disj2(equals(:tea, t), equals(:cup, t))
+          end
+
+          expect(result).to be_kind_of(Core::DefRelation)
+          expect(result.name).to eq('teacupo')
+          expect(result.formals.size).to eq(1)
+          expect(result.formals[0].name).to eq('t')
+          g_template = result.goal_template
+          expect(g_template).to be_kind_of(Core::GoalTemplate)
+          expect(g_template.relation).to eq(Core::Disj2.instance)
+
+          first_arg = g_template.args[0]
+          expect(first_arg).to be_kind_of(Core::GoalTemplate)
+          expect(first_arg.relation).to eq(Core::Equals.instance)
+          expect(first_arg.args[0]).to eq(:tea)
+          expect(first_arg.args[1]).to be_kind_of(Core::FormalRef)
+          expect(first_arg.args[1].name).to eq('t')
+          second_arg = g_template.args[1]
+          expect(second_arg).to be_kind_of(Core::GoalTemplate)
+          expect(second_arg.relation).to eq(Core::Equals.instance)
+          expect(second_arg.args[0]).to eq(:cup)
+          expect(second_arg.args[1]).to be_kind_of(Core::FormalRef)
+          expect(second_arg.args[1].name).to eq('t')
+        end
+
+        def defrel_teacupo
+          defrel('teacupo', 't') { disj2(equals(:tea, t), equals(:cup, t)) }
+        end
+
+        it "supports the invokation of a 'defrel' and passes frame 1:83" do
+          # Reasoned S2, frame 1:83
+          # (run* x
+          #   (teacupo x)) ;; => ((tea cup))
+
+          defrel_teacupo
+          result = run_star('x', teacupo(x))
+
+          expect(result).to eq(cons(:tea, cons(:cup)))
+        end
+
+        it 'supports booleans and passes frame 1:84' do
+          # Reasoned S2, frame 1:84
+          # (run* (x y)
+          #   (disj2
+          #     (conj2 (teacupo x) (== #t y))
+          #     (conj2 (== #f x) (== #t y))) ;; => ((#f #t)(tea #t) (cup #t))
+
+          defrel_teacupo
+          result = run_star(%w[x y],
+            disj2(
+              conj2(teacupo(x), equals('#t', y)),
+              conj2(equals('#f', x), equals('#t', y))))
+
+          # Order of solutions differs from RS book
+          expect(result.car).to eq(cons(:tea, cons(true)))
+          expect(result.cdr.car).to eq(cons(:cup, cons(true)))
+          expect(result.cdr.cdr.car).to eq(cons(false, cons(true)))
+        end
+
+        it 'passes frame 1:85' do
+          # Reasoned S2, frame 1:85
+          # (run* (x y)
+          #   (teacupo x)
+          #   (teacupo y)) ;; => ((tea tea)(tea cup)(cup tea)(cup c))
+
+          defrel_teacupo
+          result = run_star(%w[x y], [teacupo(x), teacupo(y)])
+
+          expect(result.car).to eq(cons(:tea, cons(:tea)))
+          expect(result.cdr.car).to eq(cons(:tea, cons(:cup)))
+          expect(result.cdr.cdr.car).to eq(cons(:cup, cons(:tea)))
+          expect(result.cdr.cdr.cdr.car).to eq(cons(:cup, cons(:cup)))
+        end
+
+        it 'passes frame 1:86' do
+          # Reasoned S2, frame 1:86
+          # (run* (x y)
+          #   (teacupo x)
+          #   (teacupo x)) ;; => ((tea _0)(cup _0))
+
+          defrel_teacupo
+          result = run_star(%w[x y], [teacupo(x), teacupo(x)])
+
+          expect(result.car).to eq(cons(:tea, cons(:_0)))
+          expect(result.cdr.car).to eq(cons(:cup, cons(:_0)))
+        end
+
+        it 'passes frame 1:87' do
+          # Reasoned S2, frame 1:87
+          # (run* (x y)
+          #   (disj2
+          #     (conj2 (teacupo x) (teacupo x))
+          #     (conj2 (== #f x) (teacupo y)))) ;; => ((#f tea)(#f cup)(tea _0)(cup _0))
+
+          defrel_teacupo
+          result = run_star(%w[x y], disj2(
+              conj2(teacupo(x), teacupo(x)),
+              conj2(equals('#f', x), teacupo(y))))
+
+          # Order of solutions differs from RS book
+          expect(result.car).to eq(cons(:tea, cons(:_0)))
+          expect(result.cdr.car).to eq(cons(:cup, cons(:_0)))
+          expect(result.cdr.cdr.car).to eq(cons(false, cons(:tea)))
+          expect(result.cdr.cdr.cdr.car).to eq(cons(false, cons(:cup)))
         end
       end # context
     end # describe

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_kraken
 version: !ruby/object:Gem::Version
-  version: 0.2.00
+  version: 0.2.01
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-12 00:00:00.000000000 Z
+date: 2020-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -61,6 +61,7 @@ extra_rdoc_files:
 - README.md
 files:
 - ".rspec"
+- ".rubocop.yml"
 - ".travis.yml"
 - CHANGELOG.md
 - Gemfile
@@ -109,6 +110,7 @@ files:
 - lib/mini_kraken/glue/run_star_expression.rb
 - lib/mini_kraken/version.rb
 - mini_kraken.gemspec
+- spec/.rubocop.yml
 - spec/core/association_spec.rb
 - spec/core/association_walker_spec.rb
 - spec/core/conde_spec.rb
@@ -146,9 +148,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="