activefacts 1.0.2 → 1.1.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NzcwY2M0NGUyNTljNzZmMDBlN2ExOTMyNTI3MDE0ZTMwYjU4MWY3Yw==
-  data.tar.gz: !binary |-
-    Yzk1MmFlZTJhZTZiOTY0OGMyZTNjYzExM2Q5OTJhMzQwNTNhNjQ2Nw==
+SHA1:
+  metadata.gz: 6e791a369dca69a80ccd666e7eec9441e9f00483
+  data.tar.gz: d894b07ab82cfdf942a8e93561fa86a8a3bedd8a
 SHA512:
-  metadata.gz: !binary |-
-    MTI2OTFhNWU0YjA2NWNjNmJkNDI0NzJkYWZkZGVhNGNiZDIzNTBjNWQ1MjQz
-    ODZhOWRkZDA4ZmIzNDNmYjQzZTMzMzQxYTA1Y2E5MWFkOTgyODM0NTc5MDMw
-    YzA3OWE0ZGQ3ZmFiNTlhNjE3MzlmNzM2MGNlYjY0YTgzZmVmNmI=
-  data.tar.gz: !binary |-
-    YzJmNzk1OGVmMTM3Y2E0YzE4MzJhMzg2YzVmMWE2ZjVkYjA2Y2JlODAxY2M5
-    MzE1ZGIzZDRiYzc4YjBiZTUwZDZlOWJiNjZmZjA0ZWQxMzJmNzFlODMwOTI1
-    MjM0MjAyMDFhNjgzY2I1ZTc3ZDU0OTViYzE2MmMzMTQ0Mzg0OTI=
+  metadata.gz: c5f05a7b8b3b116f478b55819baba8162b12c8807122f9825474c93819a9f0f3255dd5c2040eaf54dd59e6e445c5572bcd1d82267d3b9312af140ae8b51d8ce5
+  data.tar.gz: e6d40c1c950bbca20c96700002c88fa640c1a019c3dfe72b4e88da5a549d401d6d5d87eead9c20d6ced53c688750f7458f2ae598181a6a9c02d84775c6407ca4

data/Rakefile

@@ -1,6 +1,7 @@
 require 'rubygems'
 require 'rake'
 require 'fileutils'
+$: << "lib"
 require File.dirname(__FILE__) + '/lib/activefacts'
 
 def File.read_utf(path)
@@ -38,8 +39,7 @@ and object models in SQL, Ruby and other languages.
 
   gem.files = File.open("Manifest.txt"){|f| f.read.split(/\n/)}
   gem.executables = gem.files.grep(%r{^bin/}).map{|f| f.sub('bin/', '')}
-  gem.rdoc_options = ['-S'] +
-    # RDoc used to have these options: -A has_one -A one_to_one -A maybe
+  gem.rdoc_options =  # RDoc used to have these options: -A has_one -A one_to_one -A maybe
     %w{
       -x lib/activefacts/cql/.*.rb
       -x lib/activefacts/vocabulary/.*.rb

data/bin/afgen

@@ -64,6 +64,6 @@ begin
 rescue => e
   $stderr.puts "#{e.message}"
   # puts "\t#{e.backtrace*"\n\t"}"
-  $stderr.puts "\t#{e.backtrace*"\n\t"}" if debug :exception
+  $stderr.puts "\t#{e.backtrace*"\n\t"}" if trace :exception
   exit 1
 end

data/bin/cql

@@ -7,16 +7,6 @@
 #
 require 'readline'
 
-# Load the ruby debugger before everything else, if requested
-#if d = ENV['DEBUG'] and d.split(/,/).include?('debug')
-#  begin
-#    require 'ruby-debug'
-#    Debugger.start(:post_mortem => true)        # Stop when an exception is thrown, but before it's rescued
-#  rescue LoadError
-#    # Ok, no debugger, tough luck.
-#  end
-#end
-
 require 'activefacts'
 require 'activefacts/cql/compiler'
 
@@ -28,6 +18,11 @@ class InteractiveCQL < ActiveFacts::CQL::Compiler
     self.root = :definition
   end
 
+  def add_logger logger
+    @constellation.loggers << logger
+    @constellation.loggers.uniq!
+  end
+
   def list_instances name
     if (name.is_a?(ActiveFacts::Metamodel::ObjectType))
       name.all_instance
@@ -40,7 +35,7 @@ class InteractiveCQL < ActiveFacts::CQL::Compiler
 
   def toggle_trace words
     words.each { |word|
-      puts "#{word} #{debug_toggle(word) ? "en" : "dis"}abled"
+      puts "#{word} #{trace.toggle(word) ? "en" : "dis"}abled"
     }
   end
 
@@ -79,7 +74,7 @@ class InteractiveCQL < ActiveFacts::CQL::Compiler
     case cmd = words.shift
     when "/trace"
       if words.empty?
-	puts debug_keys*", "
+	puts trace_keys*", "
       else
 	toggle_trace words
       end
@@ -89,6 +84,13 @@ class InteractiveCQL < ActiveFacts::CQL::Compiler
     when "/highlight"
       @show_highlight = !@show_highlight
       puts "Will #{@show_highlight ? "" : "not "}show the highlighted parse"
+    when "/log"
+      @logger ||= proc {|*a|
+	unless @undoing
+	  print "LOG: "; p a
+	end
+      }
+      add_logger @logger
     when "/timings"
       $show_timings = !$show_timings
       puts "Will #{$show_timings ? "" : "not "}show command timings"
@@ -103,13 +105,13 @@ class InteractiveCQL < ActiveFacts::CQL::Compiler
       end
     when "/load"
       load_file(words*' ')
+    when "/quit"
+      exit
+    when "/help", "/"
+      help words
     else
-      if cmd == "/help" or cmd == "/"
-	help words
-      else
-	puts "Unknown metacommand #{line}?"
-	help
-      end
+      puts "Unknown metacommand #{line}?"
+      help
     end
   end
 
@@ -124,17 +126,57 @@ class InteractiveCQL < ActiveFacts::CQL::Compiler
       $stderr.puts e.message
     rescue => e
       puts e.message
-      puts "\t#{e.backtrace*"\n\t"}" if debug :exception
+      puts "\t#{e.backtrace*"\n\t"}" if trace :exception
     end
   end
 
-  def process_query(join)
-    if join.all_join_node.size == 1 and join.all_join_step.size == 0
-      list_instances(join.all_join_node.single.object_type)
+  def process_query(query)
+    result_projection = {}  # A set of {hash of Variable to Instance}
+    query_block =
+      proc do |unbound_variables = [], bindings = {}|
+	# unbound_variables is an array of the remaining dimensions of the search
+	# bindings is a hash of Varable to Instance
+	next_variable = unbound_variables[0]
+	if next_variable
+	  ins = next_variable.object_type.all_instance
+	  trace :result, "Query search through #{ins.size} #{next_variable.role_name || next_variable.object_type.name}" do
+	    next_variable.object_type.all_instance.each do |instance|
+	      trace :result, "Considering #{instance.verbalise}"
+	      # REVISIT: Check whether this instance satisfies the query steps that contain the bound variables
+	      (b = bindings.dup).store(next_variable, instance)
+	      result_projection[b] = true
+	      query_block.call(unbound_variables[1..-1], b)
+	    end
+	  end
+	end
+      end
+
+    unbound_variables = query.all_variable.to_a
+    bound_variables = {}
+    unbound_variables.reject!{|v| v.value != nil ? bound_variables[v] = v.value : nil }
+    print 'bound variables: '; p bound_variables.keys.map{|v| [v.object_type.name, v.value.inspect] }
+    print 'unbound variables: '; p unbound_variables.map{|v| v.object_type.name} 
+
+    query_block.call(unbound_variables, {})
+    result_projection.map do |result, _|
+      puts(result.map{|v, i| i.verbalise }.join(', '))
+    end
+
+=begin
+    if query.all_variable.size == 1 and
+    	(v = query.all_variable.single).all_play.map{|p| p.all_step.to_a}.flatten.uniq.size == 0
+      if v.object_type.all_instance.size == 0
+	puts "There are no instances of #{v.object_type.name}"
+      else
+	list_instances(v.object_type)
+      end
     else
-      # REVISIT: Identify all the unbound Join Nodes, and do a nested-loops iteration checking all Steps
-      puts "Can't yet process complex queries (involving #{join.all_join_node.map{|jn|jn.object_type.name}*', '})"
+      # REVISIT: Identify all the unbound Variables, and do a nested-loops iteration checking all Steps
+      puts "Can't yet process complex queries (involving #{
+	  query.all_variable.map{|v| v.object_type.name}
+	}*', '})"
     end
+=end
   end
 
   def process(statement)
@@ -148,15 +190,64 @@ class InteractiveCQL < ActiveFacts::CQL::Compiler
       end
     rescue => e
       puts e
-      puts "\t"+e.backtrace*"\n\t" if ENV["DEBUG"] =~ /exception/
+      puts "\t"+e.backtrace*"\n\t" if trace :exception
     end
   end
 
+  def start_log
+    @constellation.loggers << proc{|*a| self.log(*a) }
+    @logged = []
+  end
+
+  def log *a
+    if @undoing
+      print 'UNDO: '; p a
+    else
+      @logged << a
+    end
+  end
+
+  def undo
+    puts '>'*30+' UNDO '+'<'*30
+    @undoing = true
+    @logged.reverse.each do |a|
+      case a[0]
+      when :assert
+	action, klass, identifying_role_values = *a
+	# puts "retracting #{klass.basename} #{identifying_role_values.inspect}"
+	object = @constellation.instances[klass][identifying_role_values]
+	object && object.retract
+
+      when :retract
+	action, klass, identifying_role_values = *a
+	# puts "reasserting #{klass.basename}(#{identifying_role_values.inspect})"
+	@constellation.assert(klass, identifying_role_values)
+
+      when :assign
+	action, klass, role, object_id, old, new = *a
+	# puts "de-assigning #{klass.basename}(#{object_id.inspect}).#{role.name} from #{new.inspect} back to #{old.inspect}"
+	object = @constellation.instances[klass][object_id]
+	object.send(role.setter, old)
+
+      else raise "Unexpected log action #{a[0]}"
+      end
+    end
+    @undoing = false
+  end
+
   def compile_definition ast
     # Accumulate the results:
     p ast if @show_tree
     puts highlight_tree(ast.tree) if @show_highlight
-    result = super
+    begin
+      start_log
+      result = super
+    rescue => e
+      undo
+      raise
+    ensure
+      @constellation.loggers.pop
+    end
     @results += Array(result)
     result
   end
@@ -196,7 +287,7 @@ Meta-commands are:
   /root rule\t\tParse just a fragment of a CQL statement, matching syntax rule only
   /timings\t\t\tDisplay the elapsed time to execute each command
   /tree\t\t\tDisplay the abstract syntax tree from each statement parsed
-  /trace key\t\tToggle debug tracing key, or list available keys
+  /trace key\t\tToggle tracing key, or list available keys
 }
     else
       words.each do |word|

data/examples/CQL/Insurance.cql

@@ -218,14 +218,14 @@ Person was Driving,
 	Driving was by one Person;
 
 Driving Charge is where
-	Driving resulted in one Charge;
+	Driving resulted in at most one Charge;
 Driving Charge is a warning;
 
 Finance Institution is a kind of Company;
 Vehicle is subject to finance with at most one Finance Institution;
 
 Hospitalization is where
-	Driving resulted in driver taken to one Hospital;
+	Driving resulted in driver taken to at most one Hospital;
 Hospitalization resulted in at most one blood-Test Result;
 
 Insured is a kind of Party;

data/examples/CQL/Metamodel.cql

@@ -173,9 +173,9 @@ Name is of at most one Unit,
 	Unit is called one Name;
 Unit has at most one Coefficient;
 Unit has at most one Offset;
-Unit has plural-Name;  // Avoid ambiguity; this is a new fact type
-Unit has at most one plural-Name,
-	plural-Name is of at most one Unit;
+Unit (as Plural Named Unit) has plural-Name;  // Avoid ambiguity; this is a new fact type
+Unit (as Plural Named Unit) has at most one plural-Name,
+	plural-Name is of at most one Plural Named Unit;
 Unit is fundamental;
 
 Value is identified by Literal and Value is literal string and Unit where

data/examples/CQL/SchoolActivities.cql

@@ -22,7 +22,7 @@ Student is enrolled in one School;
 
 Student Participation is where
 	Student represents School in Activity,
-	Student participates in Activity which is sanctioned by one School;
+	Student participates in Activity as representative of one School;
 
 /*
  * Constraints:

data/examples/CQL/Warehousing.cql

@@ -82,19 +82,20 @@ Transfer Request is from one Warehouse (as From Warehouse);
 Transfer Request is to one Warehouse (as To Warehouse);
 Warehouse contains at least one Bin;
 
+Back Order Allocation is where
+	Purchase Order Item is allocated to Sales Order Item;
+Back Order Allocation is for one Quantity;
+
 Customer is a kind of Party;
 Customer made Sales Order,
 	Sales Order was made by one Customer;
 
-Direct Order Match is where
-	Purchase Order Item matches Sales Order Item;
-
 /*
  * Constraints:
  */
 either Dispatch Item is for Transfer Request or Dispatch Item is for Sales Order Item but not both;
 either Received Item is for Purchase Order Item or Received Item is for Transfer Request but not both;
-Purchase Order Item matches Sales Order Item
+Purchase Order Item is allocated to Sales Order Item
 	only if Purchase Order Item is for Product that is in Sales Order Item;
 each Bin occurs at most one time in
 	Warehouse contains Bin;

data/lib/activefacts/cql.rb

@@ -19,7 +19,7 @@ module ActiveFacts
   #   require 'activefacts/cql'
   class CQLLoader
     def self.load(file) #:nodoc:
-      debug "Loading #{file}" do
+      trace "Loading #{file}" do
         vocabulary = ActiveFacts::Input::CQL.readfile(file)
 
         ruby = StringIO.new

data/lib/activefacts/cql/Language/English.treetop

@@ -155,6 +155,7 @@ module ActiveFacts
 	    # "that" on the other hand means that this role player was *previously* designated using "some".
 	    # These distinctions are lost here
 	  / that s                  { def value; nil; end }
+	  / which s                 { def value; nil; end }
 	  / one s                   { def value; [1, 1]; end }
 	  / no s                    { def value; [0, 0]; end }
 	  / exactly s quantity      { def value; q = quantity.value; [q, q]; end }
@@ -264,7 +265,7 @@ module ActiveFacts
       rule in 'in' !alphanumeric end
       rule import 'import' !alphanumeric end
       rule independent 'independent' !alphanumeric end 
-      rule stronglyintransitive 'stronglyintransitive' !alphanumeric end
+      rule stronglyintransitive 'strongly' s 'intransitive' !alphanumeric end
       rule intransitive 'intransitive' !alphanumeric end
       rule irreflexive 'irreflexive' !alphanumeric end
       rule is 'is' !alphanumeric end 

data/lib/activefacts/cql/compiler.rb

@@ -29,7 +29,7 @@ module ActiveFacts
         super *a
         @constellation = ActiveFacts::API::Constellation.new(ActiveFacts::Metamodel)
         @language = nil
-        debug :file, "Parsing '#{@filename}'"
+        trace :file, "Parsing '#{@filename}'"
       end
 
       def compile_file filename
@@ -64,16 +64,16 @@ module ActiveFacts
         # The syntax tree created from each parsed CQL statement gets passed to the block.
         # parse_all returns an array of the block's non-nil return values.
         ok = parse_all(@string, :definition) do |node|
-          debug :parse, "Parsed '#{node.text_value.gsub(/\s+/,' ').strip}'" do
+          trace :parse, "Parsed '#{node.text_value.gsub(/\s+/,' ').strip}'" do
             begin
               ast = node.ast
               next unless ast
-              debug :ast, ast.inspect
+              trace :ast, ast.inspect
               ast.tree = node
               ast.constellation = @constellation
               ast.vocabulary = @vocabulary
               value = compile_definition ast
-              debug :definition, "Compiled to #{value.is_a?(Array) ? value.map{|v| v.verbalise}*', ' : value.verbalise}" if value
+              trace :definition, "Compiled to #{value.is_a?(Array) ? value.map{|v| v.verbalise}*', ' : value.verbalise}" if value
               @vocabulary = value if ast.is_a?(Compiler::Vocabulary)
             rescue => e
               # Augment the exception message, but preserve the backtrace
@@ -122,8 +122,8 @@ module ActiveFacts
 
       def unit? s
         name = @constellation.Name[s]
-        units = (!name ? [] : Array(name.unit) + Array(name.unit_as_plural_name)).uniq
-        debug :units, "Looking for unit #{s}, got #{units.map{|u|u.name}.inspect}"
+        units = (!name ? [] : Array(name.unit) + Array(name.plural_named_unit)).uniq
+        trace :units, "Looking for unit #{s}, got #{units.map{|u|u.name}.inspect}"
         units.size > 0
       end
 

data/lib/activefacts/cql/compiler/clause.rb

@@ -108,6 +108,8 @@ module ActiveFacts
           end
         end
 
+	# This method is used in matching unary fact types in entity identification
+	# It disregards literals, which are not allowed in this context.
         def phrases_match(phrases)
           @phrases.zip(phrases).each do |mine, theirs|
             return false if mine.is_a?(Reference) != theirs.is_a?(Reference)
@@ -135,7 +137,7 @@ module ActiveFacts
           changed_conjunction = (lcc = context.left_contraction_conjunction) && lcc != conjunction
           if context.left_contraction_allowed && (new_conjunction || changed_conjunction)
             # Conjunctions are that/who, where, comparison-operator, ','
-            debug :matching, "A left contraction will be against #{self.inspect}, conjunction is #{conjunction.inspect}"
+            trace :matching, "A left contraction will be against #{self.inspect}, conjunction is #{conjunction.inspect}"
             context.left_contractable_clause = self
             left_contract_this_onto = nil # Can't left-contract this clause
           end
@@ -162,7 +164,7 @@ module ActiveFacts
             vrs.unshift contracted_role
             contracted_left = true
             phrases = [contracted_role]+phrases
-            debug :matching, "Failed to match #{inspect}. Trying again using left contraction onto #{contraction_player.name}"
+            trace :matching, "Failed to match #{inspect}. Trying again using left contraction onto #{contraction_player.name}"
           end
 
           contract_right = proc do
@@ -176,7 +178,7 @@ module ActiveFacts
             contracted_role.bind(context)
             vrs.push contracted_role
             phrases = phrases+[contracted_role]
-            debug :matching, "Failed to match #{inspect}. Trying again using right contraction onto #{contraction_player.name}"
+            trace :matching, "Failed to match #{inspect}. Trying again using right contraction onto #{contraction_player.name}"
           end
 
           begin
@@ -193,8 +195,8 @@ module ActiveFacts
 
             player_names = players.map{|p| p.name}
 
-            debug :matching, "Looking for existing #{players.size}-ary fact types matching '#{inspect(phrases)}'" do
-              debug :matching, "Players are '#{player_names.inspect}'"
+            trace :matching, "Looking for existing #{players.size}-ary fact types matching '#{inspect(phrases)}'" do
+              trace :matching, "Players are '#{player_names.inspect}'"
 
               # Match existing fact types in nested clauses first:
               # (not for contractions) REVISIT: Why not?
@@ -223,7 +225,7 @@ module ActiveFacts
                     player.subtypes_transitive).uniq
                 end
 
-              debug :matching, "Players must match '#{player_related_types.map{|pa| pa.map{|p|p.name}}.inspect}'"
+              trace :matching, "Players must match '#{player_related_types.map{|pa| pa.map{|p|p.name}}.inspect}'"
 
               start_obj = player_related_types[0] || [left_contract_this_onto.refs[-1].player]
               # The candidate fact types have the right number of role players of related types.
@@ -238,7 +240,7 @@ module ActiveFacts
 
 		    compatible_readings = role.fact_type.compatible_readings(player_related_types)
 		    next unless compatible_readings.size > 0
-		    debug :matching_fails, "These readings are compatible: #{compatible_readings.map(&:expand).inspect}"
+		    trace :matching_fails, "These readings are compatible: #{compatible_readings.map(&:expand).inspect}"
                     true
                   end.
                     map{ |role| role.fact_type}
@@ -246,7 +248,7 @@ module ActiveFacts
 
               # If there is more than one possible exact match (same adjectives) with different subyping, the implicit query is ambiguous and is not allowed
 
-              debug :matching, "Looking amongst #{candidate_fact_types.size} existing fact types for one matching #{left_insertion}'#{inspect}'#{right_insertion}" do
+              trace :matching, "Looking amongst #{candidate_fact_types.size} existing fact types for one matching #{left_insertion}'#{inspect}'#{right_insertion}" do
                 matches = {}
                 candidate_fact_types.map do |fact_type|
                   fact_type.all_reading.map do |reading|
@@ -266,7 +268,7 @@ module ActiveFacts
                   # Between equivalents, prefer the one without steps on the first role
                   (m = matches[match]).cost*2 + ((!(e = m.role_side_effects[0]) || e.cost) == 0 ? 0 : 1)
                 }
-                debug :matching_fails, "Found #{matches.size} valid matches#{matches.size > 0 ? ', best is '+best_matches[0].expand : ''}"
+                trace :matching_fails, "Found #{matches.size} valid matches#{matches.size > 0 ? ', best is '+best_matches[0].expand : ''}"
 
                 if matches.size > 1
                   first = matches[best_matches[0]]
@@ -284,14 +286,14 @@ module ActiveFacts
                   @reading = best_matches[0]
                   @side_effects = matches[@reading]
                   @fact_type = @side_effects.fact_type
-                  debug :matching, "Matched '#{@fact_type.default_reading}'"
+                  trace :matching, "Matched '#{@fact_type.default_reading}'"
                   @phrases = phrases
                   apply_side_effects(context, @side_effects)
                   return @fact_type
                 end
 
               end
-              debug :matching, "No fact type matched, candidates were '#{candidate_fact_types.map{|ft| ft.default_reading}*"', '"}'"
+              trace :matching, "No fact type matched, candidates were '#{candidate_fact_types.map{|ft| ft.default_reading}*"', '"}'"
             end
             if left_contract_this_onto
               if !contracted_left
@@ -341,21 +343,21 @@ module ActiveFacts
           # REVISIT: the verbaliser will need to know about a negated step to a free variable
           implicitly_negated = true if refs.detect{|ref| q = ref.quantifier and q.is_zero }
 
-          debug :matching_fails, "Does '#{phrases.inspect}' match '#{reading.expand}'" do
+          trace :matching_fails, "Does '#{phrases.inspect}' match '#{reading.expand}'" do
             phrase_num = 0
             reading_parts = reading.text.split(/\s+/)
             reading_parts.each do |element|
               phrase = phrases[phrase_num]
               if phrase == 'not'
                 raise "Stop playing games with your double negatives: #{phrases.inspect}" if implicitly_negated
-                debug :matching, "Negation detected"
+                trace :matching, "Negation detected"
                 implicitly_negated = true
                 phrase = phrases[phrase_num += 1]
               end
               if element !~ /\{(\d+)\}/
                 # Just a word; it must match
                 unless phrase == element
-                  debug :matching_fails, "Mismatched ordinary word #{phrases[phrase_num].inspect} (wanted #{element})"
+                  trace :matching_fails, "Mismatched ordinary word #{phrases[phrase_num].inspect} (wanted #{element})"
                   return nil
                 end
                 phrase_num += 1
@@ -388,11 +390,11 @@ module ActiveFacts
                 # This relies on the supertypes being in breadth-first order:
                 common_supertype = (next_player.supertypes_transitive & player.supertypes_transitive)[0]
                 if !common_supertype
-                  debug :matching_fails, "Reading discounted because next player #{player.name} doesn't match #{next_player.name}"
+                  trace :matching_fails, "Reading discounted because next player #{player.name} doesn't match #{next_player.name}"
                   return nil
                 end
 
-                debug :matching_fails, "Subtype step is required between #{player.name} and #{next_player_phrase.player.name} via common supertype #{common_supertype.name}"
+                trace :matching_fails, "Subtype step is required between #{player.name} and #{next_player_phrase.player.name} via common supertype #{common_supertype.name}"
               else
                 if !next_player_phrase
                   next    # Contraction succeeded so far
@@ -460,7 +462,7 @@ module ActiveFacts
               if a = (!phrase.role_name.is_a?(Integer) && phrase.role_name) and
                   e = role_ref.role.role_name and
                   a != e
-                debug :matching, "Role names #{e.inspect} for #{player.name} and #{a.inspect} for #{next_player_phrase.player.name} don't match"
+                trace :matching, "Role names #{e.inspect} for #{player.name} and #{a.inspect} for #{next_player_phrase.player.name} don't match"
                 return nil
               end
 =end
@@ -469,7 +471,7 @@ module ActiveFacts
               if residual_adjectives && next_player_phrase.binding.refs.size == 1
                 # This makes matching order-dependent, because there may be no "other purpose"
                 # until another reading has been matched and the roles rebound.
-                debug :matching_fails, "Residual adjectives have no other purpose, so this match fails"
+                trace :matching_fails, "Residual adjectives have no other purpose, so this match fails"
                 return nil
               end
 
@@ -478,7 +480,7 @@ module ActiveFacts
             end
 
             if phrase_num != phrases.size || !intervening_words.empty?
-              debug :matching_fails, "Extra words #{(intervening_words + phrases[phrase_num..-1]).inspect}"
+              trace :matching_fails, "Extra words #{(intervening_words + phrases[phrase_num..-1]).inspect}"
               return nil
             end
 
@@ -486,7 +488,7 @@ module ActiveFacts
               # There may be only one subtyping step on a TypeInheritance fact type.
               ti_steps = side_effects.select{|side_effect| side_effect.common_supertype}
               if ti_steps.size > 1   # Not allowed
-                debug :matching_fails, "Can't have more than one subtyping step on a TypeInheritance fact type"
+                trace :matching_fails, "Can't have more than one subtyping step on a TypeInheritance fact type"
                 return nil
               end
 
@@ -496,13 +498,13 @@ module ActiveFacts
                     fact_type.subtype.supertypes_transitive :
                     fact_type.supertype.subtypes_transitive
                 if !allowed.include?(ti.common_supertype)
-                  debug :matching_fails, "Implicit subtyping step extends in the wrong direction"
+                  trace :matching_fails, "Implicit subtyping step extends in the wrong direction"
                   return nil
                 end
               end
             end
 
-            debug :matching, "Matched reading '#{reading.expand}' (with #{
+            trace :matching, "Matched reading '#{reading.expand}' (with #{
                   side_effects.map{|side_effect|
                     side_effect.absorbed_precursors+side_effect.absorbed_followers + (side_effect.common_supertype ? 1 : 0)
                   }.inspect
@@ -518,12 +520,12 @@ module ActiveFacts
           @applied_side_effects = side_effects
           # Enact the side-effects of this match (delete the consumed adjectives):
           # Since this deletes words from the phrases, we do it in reverse order.
-          debug :matching, "Apply side-effects" do
+          trace :matching, "Apply side-effects" do
             side_effects.apply_all do |side_effect|
               phrase = side_effect.phrase
 
               # We re-use the role_ref if possible (no extra adjectives were used, no rolename or step, etc).
-              debug :matching, "side-effect means binding #{phrase.inspect} matches role ref #{side_effect.role_ref.role.object_type.name}"
+              trace :matching, "side-effect means binding #{phrase.inspect} matches role ref #{side_effect.role_ref.role.object_type.name}"
               phrase.role_ref = side_effect.role_ref
 
               changed = false
@@ -532,7 +534,7 @@ module ActiveFacts
               # the role_ref, those must be local, and we'll need to extract them.
 
               if rra = side_effect.role_ref.trailing_adjective
-                debug :matching, "Deleting matched trailing adjective '#{rra}'#{side_effect.absorbed_followers>0 ? " in #{side_effect.absorbed_followers} followers" : ""}, cost is #{side_effect.cost}"
+                trace :matching, "Deleting matched trailing adjective '#{rra}'#{side_effect.absorbed_followers>0 ? " in #{side_effect.absorbed_followers} followers" : ""}, cost is #{side_effect.cost}"
                 side_effect.cancel_cost side_effect.absorbed_followers
 
                 # These adjective(s) matched either an adjective here, or a follower word, or both.
@@ -552,7 +554,7 @@ module ActiveFacts
               end
 
               if rra = side_effect.role_ref.leading_adjective
-                debug :matching, "Deleting matched leading adjective '#{rra}'#{side_effect.absorbed_precursors>0 ? " in #{side_effect.absorbed_precursors} precursors" : ""}, cost is #{side_effect.cost}"
+                trace :matching, "Deleting matched leading adjective '#{rra}'#{side_effect.absorbed_precursors>0 ? " in #{side_effect.absorbed_precursors} precursors" : ""}, cost is #{side_effect.cost}"
                 side_effect.cancel_cost side_effect.absorbed_precursors
 
                 # These adjective(s) matched either an adjective here, or a precursor word, or both.
@@ -582,7 +584,7 @@ module ActiveFacts
         # Don't assign @fact_type; that will happen when the reading is added
         def make_fact_type vocabulary
           fact_type = vocabulary.constellation.FactType(:new)
-          debug :matching, "Making new fact type for #{@phrases.inspect}" do
+          trace :matching, "Making new fact type for #{@phrases.inspect}" do
             @phrases.each do |phrase|
               next unless phrase.respond_to?(:player)
               phrase.role = vocabulary.constellation.Role(fact_type, fact_type.all_role.size, :object_type => phrase.player, :concept => :new)
@@ -598,7 +600,7 @@ module ActiveFacts
           @role_sequence = constellation.RoleSequence(:new)
           reading_words = @phrases.clone
           index = 0
-          debug :matching, "Making new reading for #{@phrases.inspect}" do
+          trace :matching, "Making new reading for #{@phrases.inspect}" do
             reading_words.map! do |phrase|
               if phrase.respond_to?(:player)
                 # phrase.role will be set if this reading was used to make_fact_type.
@@ -662,7 +664,7 @@ module ActiveFacts
               if phrase.role_name != phrase.role_ref.role.role_name ||
                   phrase.leading_adjective ||
                   phrase.trailing_adjective
-                debug :matching, "phrase in matched clause has residual adjectives or role name, so needs a new role_sequence" if @fact_type.all_reading.size > 0
+                trace :matching, "phrase in matched clause has residual adjectives or role name, so needs a new role_sequence" if @fact_type.all_reading.size > 0
                 new_role_sequence_needed = true
               end
             else
@@ -671,7 +673,7 @@ module ActiveFacts
             end
           end
 
-          debug :matching, "Clause '#{reading_words*' '}' #{new_role_sequence_needed ? 'requires' : 'does not require'} a new Role Sequence"
+          trace :matching, "Clause '#{reading_words*' '}' #{new_role_sequence_needed ? 'requires' : 'does not require'} a new Role Sequence"
 
           constellation = @fact_type.constellation
           reading_text = reading_words*" "
@@ -693,15 +695,15 @@ module ActiveFacts
                 extra_adjectives << "(as #{a})"
               end
             end
-            debug :matching, "Making new role sequence for new reading #{reading_text} due to #{extra_adjectives.inspect}"
+            trace :matching, "Making new role sequence for new reading #{reading_text} due to #{extra_adjectives.inspect}"
           else
             # Use existing RoleSequence
             @role_sequence = role_phrases[0].role_ref.role_sequence
             if @role_sequence.all_reading.detect{|r| r.text == reading_text }
-              debug :matching, "No need to re-create identical reading for #{reading_text}"
+              trace :matching, "No need to re-create identical reading for #{reading_text}"
               return @role_sequence
             else
-              debug :matching, "Using existing role sequence for new reading '#{reading_text}'"
+              trace :matching, "Using existing role sequence for new reading '#{reading_text}'"
             end
           end
           if @fact_type.all_reading.
@@ -738,7 +740,7 @@ module ActiveFacts
             end
 
             # REVISIT: Check maybe and other qualifiers:
-            debug :constraint, "Need to make constraints for #{@qualifiers.inspect}" if @qualifiers.size > 0 or @certainty != true
+            trace :constraint, "Need to make constraints for #{@qualifiers.inspect}" if @qualifiers.size > 0 or @certainty != true
           end
         end
 
@@ -762,7 +764,7 @@ module ActiveFacts
           @common_supertype = common_supertype
           @residual_adjectives = residual_adjectives
           @cancelled_cost = 0
-          debug :matching_fails, "Saving side effects for #{@phrase.term}, absorbs #{@absorbed_precursors}/#{@absorbed_followers}#{@common_supertype ? ', step over supertype '+ @common_supertype.name : ''}" if @absorbed_precursors+@absorbed_followers+(@common_supertype ? 1 : 0) > 0
+          trace :matching_fails, "Saving side effects for #{@phrase.term}, absorbs #{@absorbed_precursors}/#{@absorbed_followers}#{@common_supertype ? ', step over supertype '+ @common_supertype.name : ''}" if @absorbed_precursors+@absorbed_followers+(@common_supertype ? 1 : 0) > 0
         end
 
         def cost
@@ -921,8 +923,9 @@ module ActiveFacts
             l = @leading_adjective
             t = @trailing_adjective
             key = [!l || l.empty? ? nil : l, @term, !t || t.empty? ? nil : t]
-            key
           end
+	  key += [:literal, literal.literal] if @literal
+	  key
         end
 
         def bind context
@@ -940,14 +943,34 @@ module ActiveFacts
               role_name = @term
             end
           end
-          @binding = (context.bindings[key] ||= Binding.new(@player, role_name))
-          @binding.refs << self
+	  k = key
+	  @binding = context.bindings[k]
+	  if !@binding
+	    if !literal
+	      # Find a binding that has a literal, and bind to it if it's the only one
+	      candidates = context.bindings.map do |binding_key, binding|
+		  binding_key[0...k.size] == k &&
+		    binding_key[-2] == :literal ? binding : nil
+		end.compact
+	      raise "Uncertain binding reference for #{to_s}, could be any of #{candidates.inspect}" if candidates.size > 1
+	      @binding = candidates[0]
+	    else
+	      # New binding has a literal, look for one without:
+	      @binding = context.bindings[k[0...-2]]
+	    end
+	  end
+
+	  if !@binding
+	    @binding = Binding.new(@player, role_name)
+	    context.bindings[k] = @binding
+	  end
+          @binding.add_ref self
           @binding
         end
 
         def unbind context
           # The key has changed.
-          @binding.refs.delete(self)
+          @binding.delete_ref self
           if @binding.refs.empty?
             # Remove the binding from the context if this was the last reference
             context.bindings.delete_if {|k,v| v == @binding }
@@ -961,7 +984,7 @@ module ActiveFacts
         end
 
         def rebind_to(context, other_ref)
-          debug :binding, "Rebinding #{inspect} to #{other_ref.inspect}"
+          trace :binding, "Rebinding #{inspect} to #{other_ref.inspect}"
 
           old_binding = binding   # Remember to move all refs across
           unbind(context)
@@ -969,7 +992,7 @@ module ActiveFacts
           new_binding = other_ref.binding
           [self, *old_binding.refs].each do |ref|
             ref.binding = new_binding
-            new_binding.refs << ref
+            new_binding.add_ref ref
           end
           old_binding.rebound_to = new_binding
         end
@@ -999,20 +1022,20 @@ module ActiveFacts
           fact_type = @role_ref.role.fact_type
           constellation = vocabulary.constellation
 
-          debug :constraint, "Processing embedded constraint #{@quantifier.inspect} on #{@role_ref.role.object_type.name} in #{fact_type.describe}" do
+          trace :constraint, "Processing embedded constraint #{@quantifier.inspect} on #{@role_ref.role.object_type.name} in #{fact_type.describe}" do
             # Preserve the role order of the clause, excluding this role:
             constrained_roles = (@clause.refs-[self]).map{|vr| vr.role_ref.role}
             if constrained_roles.empty?
-              debug :constraint, "Quantifier over unary role has no effect"
+              trace :constraint, "Quantifier over unary role has no effect"
               return
             end
             constraint = find_pc_over_roles(constrained_roles)
             if constraint
               raise "Conflicting maximum frequency for constraint" if constraint.max_frequency && constraint.max_frequency != @quantifier.max
-              debug :constraint, "Setting max frequency to #{@quantifier.max} for existing constraint #{constraint.object_id} over #{constraint.role_sequence.describe} in #{fact_type.describe}" unless constraint.max_frequency
+              trace :constraint, "Setting max frequency to #{@quantifier.max} for existing constraint #{constraint.object_id} over #{constraint.role_sequence.describe} in #{fact_type.describe}" unless constraint.max_frequency
               constraint.max_frequency = @quantifier.max
               raise "Conflicting minimum frequency for constraint" if constraint.min_frequency && constraint.min_frequency != @quantifier.min
-              debug :constraint, "Setting min frequency to #{@quantifier.min} for existing constraint #{constraint.object_id} over #{constraint.role_sequence.describe} in #{fact_type.describe}" unless constraint.min_frequency
+              trace :constraint, "Setting min frequency to #{@quantifier.min} for existing constraint #{constraint.object_id} over #{constraint.role_sequence.describe} in #{fact_type.describe}" unless constraint.min_frequency
               constraint.min_frequency = @quantifier.min
             else
               role_sequence = constellation.RoleSequence(:new)
@@ -1027,7 +1050,7 @@ module ActiveFacts
                   :max_frequency => @quantifier.max,
                   :min_frequency => @quantifier.min
                 )
-              debug :constraint, "Made new embedded PC GUID=#{constraint.concept.guid} min=#{@quantifier.min.inspect} max=#{@quantifier.max.inspect} over #{(e = fact_type.entity_type) ? e.name : role_sequence.describe} in #{fact_type.describe}"
+              trace :constraint, "Made new embedded PC GUID=#{constraint.concept.guid} min=#{@quantifier.min.inspect} max=#{@quantifier.max.inspect} over #{(e = fact_type.entity_type) ? e.name : role_sequence.describe} in #{fact_type.describe}"
               @quantifier.enforcement.compile(constellation, constraint) if @quantifier.enforcement
               @embedded_presence_constraint = constraint
             end