mini_kraken 0.1.12 → 0.2.03

data/lib/mini_kraken/core/k_boolean.rb

@@ -12,6 +12,10 @@ module MiniKraken
         super(validated_value(aValue))
       end
 
+      def to_s
+        value.to_s
+      end
+
       private
 
       def validated_value(aValue)

data/lib/mini_kraken/core/k_symbol.rb

@@ -11,6 +11,17 @@ module MiniKraken
       def initialize(aValue)
         super(aValue)
       end
+
+      # Returns the name or string corresponding to value.
+      # @return [String]
+      def id2name
+        value.id2name
+      end
+
+      # Returns a string representing the MiniKraken symbol.
+      def to_s
+        ":#{id2name}"
+      end
     end # class
   end # module
 end # module

data/lib/mini_kraken/core/outcome.rb

@@ -24,7 +24,11 @@ unless MiniKraken::Core.constants(false).include? :Outcome
           new(:"#s", aParent)
         end
 
-        def successful?
+        def failure?
+          resultant != :"#s"
+        end
+
+        def success?
           resultant == :"#s"
         end
 
@@ -39,6 +43,12 @@ unless MiniKraken::Core.constants(false).include? :Outcome
           are_equal
         end
 
+        # Remove associations of variables of this environment, if
+        # persistence flag is set to false.
+        def prune!
+          parent.prune(self)
+        end
+
         protected
 
         def introspect

data/lib/mini_kraken/core/variable.rb

@@ -24,11 +24,17 @@ module MiniKraken
         name != i_name
       end
 
-      def quote(anEnvironment)
-        raise StandardError, "class #{anEnvironment}" unless anEnvironment.kind_of?(Vocabulary)
+      def quote(env)
+        raise StandardError, "class #{env}" unless env.kind_of?(Vocabulary)
 
-        val = anEnvironment.quote_ref(self)
-        val.nil? ? AnyValue.new(name, anEnvironment) : val
+        val = env.quote_ref(self)
+        unless val
+          result = AnyValue.new(name, env, env.names_fused(name))
+        else
+          result = val
+        end
+
+        result
       end
     end # class
   end # module

data/lib/mini_kraken/core/variable_ref.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'term'
+require_relative 'designation'
 require_relative 'any_value'
 
 module MiniKraken
@@ -13,7 +14,13 @@ module MiniKraken
 
       # @param aName [String] The name of the variable
       def initialize(aName)
+        super()
         init_designation(aName)
+        name.freeze
+      end
+
+      def to_s
+        name
       end
 
       # @param aValue [Term]

data/lib/mini_kraken/core/vocabulary.rb

@@ -171,7 +171,7 @@ module MiniKraken
         to_fuse.map { |i_name| i_name2var(i_name) }
       end
 
-      # Fuse the given variables, that is:
+      # Fuse the given variables:
       # Collect all their associations
       # Put them under a new internal name
       # Remove all entries from old internal names
@@ -331,8 +331,9 @@ module MiniKraken
       #   variable name.
       # @param aName [String] User-defined variable name
       def names_fused(aName)
+        # require 'debug'
         var = name2var(aName)
-        return [] unless var.fused?
+        return [] unless var&.fused?
 
         i_name = var.i_name
         names = []
@@ -394,12 +395,16 @@ module MiniKraken
         name2var(aVarName) ? true : false
       end
 
+      def prune(anOutcome)
+        anOutcome # Don't touch outcome
+      end
+
       def inspect
         result = +"#<#{self.class.name}:#{object_id.to_s(16)} @parent="
         if parent
           result << "#<#{parent.class.name}:#{parent.object_id.to_s(16)}>"
         else
-          result << nil
+          result << 'nil'
         end
         result << introspect
         result << '>'

data/lib/mini_kraken/glue/dsl.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require 'set'
+require_relative '../core/any_value'
+require_relative '../core/conde'
+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 '../glue/fresh_env'
+require_relative '../glue/fresh_env_factory'
+require_relative '../core/goal_template'
+require_relative '../core/k_boolean'
+require_relative '../core/k_symbol'
+require_relative '../core/succeed'
+require_relative '../core/variable_ref'
+require_relative 'fresh_env'
+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
+
+      def conde(*goals)
+        # require 'debug'
+        args = goals.map do |goal_maybe|
+          if goal_maybe.kind_of?(Array)
+            goal_maybe.map { |g| convert(g) }
+          else
+            convert(goal_maybe)
+          end
+        end
+
+        Core::Goal.new(Core::Conde.instance, args)
+      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)
+       goal_class.new(Core::Conj2.instance, [convert(arg1), convert(arg2)])
+      end
+
+      def cons(car_item, cdr_item = nil)
+        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)
+        goal_class.new(Core::Disj2.instance, [convert(arg1), convert(arg2)])
+      end
+
+      # @return [Core::Fail] A goal that unconditionally fails.
+      def _fail
+        goal_class.new(Core::Fail.instance, [])
+      end
+
+      def equals(arg1, arg2)
+        # require 'debug'
+        goal_class.new(Core::Equals.instance, [convert(arg1), convert(arg2)])
+      end
+
+      def fresh(var_names, goal)
+        vars = nil
+        if @dsl_mode == :defrel
+          if var_names.kind_of?(String)
+            vars = [var_names]
+          else
+            vars = var_names
+          end
+          FreshEnvFactory.new(vars, goal)
+        else
+          if var_names.kind_of?(String) || var_names.kind_of?(Core::VariableRef)
+            vars = [var_names]
+          else
+            vars = var_names
+          end
+
+          FreshEnv.new(vars, goal)
+        end
+      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
+        goal_class.new(Core::Succeed.instance, [])
+      end
+
+      private
+
+      def convert(anArgument)
+        converted = nil
+
+        case anArgument
+          when Symbol
+            if anArgument.id2name =~ /_\d+/
+              rank = anArgument.id2name.slice(1..-1).to_i
+              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 FreshEnv
+            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
+          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
+      end
+    end # module
+  end # module
+end # module

data/lib/mini_kraken/glue/fresh_env.rb

@@ -2,13 +2,14 @@
 
 require_relative '../core/environment'
 require_relative '../core/conj2'
+require_relative '../core/goal_template'
 require_relative '../core/variable'
 
 module MiniKraken
   module Glue
     # A combination of an Environment (= a scope for one or more variables)
     # and a goal. It quacks like a Goal object: when receiving the attain message,
-    # it attempt to achieve its given goal.
+    # it attempts to achieve its given goal.
     # (fresh (x) (== 'pea q))
     # Introduces the new variable 'x'
     # Takes a list of names and a goal-like object
@@ -17,22 +18,45 @@ module MiniKraken
       # @return [Goal]
       attr_reader :goal
 
+      # @return [TrueClass, FalseClass] Do associations persist after goal exec?
+      attr_reader :persistent
+
       # @param theNames [Array<String>] The variable names
       # @param aGoal [Goal, Array<Goal>] The goal to achieve or the conjunction of them.
-      def initialize(theNames, aGoal)
+      def initialize(theNames, aGoal, persistence = true)
         super()
         @goal = valid_goal(aGoal)
-        theNames.each { |nm| add_var(Core::Variable.new(nm)) }
+        theNames.each do |nm|
+          var = Core::Variable.new(nm)
+          add_var(var)
+        end
+        @persistent = persistence
       end
 
       # Attempt to achieve the goal given this environment
       # @param aParent [Environment]
       # @return [Fiber<Outcome>] A Fiber object that will generate the results.
       def attain(aParent)
+        # require 'debug'
         self.parent = aParent
         goal.attain(self)
       end
 
+      # Remove associations of variables of this environment, if
+      # persistence flag is set to false.
+      def prune(anOutcome)
+        return super(anOutcome) if persistent
+
+        vars.each_value do |v|
+          v_name = v.name
+          if anOutcome.associations.include?(v_name)
+            anOutcome.associations.delete(v_name)
+          end
+        end
+
+        anOutcome
+      end
+
       protected
 
       def introspect
@@ -49,6 +73,8 @@ module MiniKraken
             result = aGoal
           when FreshEnv
             result = aGoal
+          when Core::GoalTemplate
+            result = aGoal
           when Array # an Array of Goal?..
             goal_array = aGoal
             loop do
@@ -66,6 +92,8 @@ module MiniKraken
               end
               goal_array = conjunctions
             end
+          else
+            raise StandardError, "Cannot handle argumment type #{aGoal.class}"
         end
 
         result