activefacts 0.8.9 → 0.8.10

data/lib/activefacts/cql/Terms.treetop

@@ -16,38 +16,41 @@ module ActiveFacts
               id.value
             ]){|a, e| a << e.id.value}*' '
           end
+
+	  def node_type
+	    :term
+	  end
         }
       end
 
       rule non_term_def
-        entity_prefix
-        / written_as                        # Value type
-        / is s mapping_pragmas where        # Objectified type
-        / non_role_word
-	/ identified_by			    # as in: "a kind of X identified by..."
+        mapping_pragmas entity_prefix
+        / mapping_pragmas written_as			      # Value type
+        / mapping_pragmas is_where			      # Objectified type
+        / non_phrase
+	/ identified_by					      # as in: "a kind of X identified by..."
 	/ unit
       end
 
       rule entity_prefix
-        is s identified_by
+        is s (independent s )? identified_by
 	/
-	subtype_prefix term_definition_name
-	&{|e| input.context.object_type(e[1].value, "subtype"); true }
+	subtype_prefix (independent s )? term_definition_name
+	&{|e| input.context.object_type(e[2].value, "subtype") }
       end
 
       rule prescan
         s (
-          term_definition_name s entity_prefix
-		&{|e| input.context.object_type(e[0].value, "entity type"); true }
+          term_definition_name mapping_pragmas entity_prefix
+		&{|e| input.context.object_type(e[0].value, "entity type") }
           /
-          t1:term_definition_name written_as t2:term_definition_name
+          t1:term_definition_name mapping_pragmas written_as t2:term_definition_name
                 &{|e| input.context.object_type(e[0].value, "value type")
-		  input.context.object_type(e[2].value, "value type")
-		  true
+		  input.context.object_type(e[3].value, "value type")
 		}
           /
-          term_definition_name s is s mapping_pragmas where
-                &{|e| input.context.object_type(e[0].value, "objectified_fact_type"); true }
+          term_definition_name s mapping_pragmas is s (independent s )? where
+                &{|e| input.context.object_type(e[0].value, "objectified_fact_type") }
         )?
         prescan_rest
         &{|s|
@@ -63,13 +66,13 @@ module ActiveFacts
       # Do a first-pass mainly lexical analysis, looking for role name definitions and adjectives,
       # for use in detecting terms later.
       rule prescan_rest
-        &{ input.context.reset_role_names }
+        &{|s| input.context.reset_role_names }
         (
           context_note                      # Context notes have different lexical conventions
           / '(' as S term_definition_name s ')' s    # Prescan for a Role Name
             &{|s| input.context.role_name(s[3].value) }
-                                            # Adjective definitions
-          / new_adjective_term
+	  / new_derived_value
+          / new_adjective_term		    # Adjective definitions
           / global_term                     # If we see A B - C D, don't recognise B as a new adjective for C D.
           / id
           / range                           # Covers all numbers and strings
@@ -79,6 +82,29 @@ module ActiveFacts
         )* [?;] s
       end
 
+      rule derived_value_continuation
+        s '-' tail:(s !global_term !(that/who) id)*
+	{
+	  def value
+	    tail.elements.map{|e| e.id.text_value}
+	  end
+	}
+      end
+
+      rule new_derived_value
+        !global_term id derived_value_continuation? s '='
+	  &{|s|
+	    name = [s[1].text_value] + (s[2].empty? ? [] : s[2].value)
+	    input.context.object_type(name*' ', "derived value type")
+	  }
+	/
+	'=' s !global_term id derived_value_continuation? s (that/who)
+	  &{|s|
+	    name = [s[3].text_value] + (s[4].empty? ? [] : s[4].value)
+	    input.context.object_type(name*' ', "derived value type")
+	  }
+      end
+
       rule new_adjective_term
         !global_term adj:id '-' lead_intervening s global_term	  # Definitely a new leading adjective for this term
           &{|s| input.context.new_leading_adjective_term([s[1].text_value, s[3].value].compact*" ", s[5].text_value) }
@@ -111,26 +137,28 @@ module ActiveFacts
         tail:(s '-'? s w:id     &{|s| w = s[3].text_value; input.context.term_continues?(w) })*
                                 &{|s| input.context.term_complete? }
         {
-	  def ast quantifier = nil, function_call = nil, role_name = nil, value_constraint = nil, literal = nil, objectification_join = nil
+	  def ast quantifier = nil, function_call = nil, role_name = nil, value_constraint = nil, literal = nil, nested_clauses = nil
 	    t = x.context[:term]
 	    gt = x.context[:global_term]
 	    leading_adjective = t[0...-gt.size-1] if t.size > gt.size and t[-gt.size..-1] == gt
 	    trailing_adjective = t[gt.size+1..-1] if t.size > gt.size and t[0...gt.size] == gt
-	    Compiler::RoleRef.new(gt, leading_adjective, trailing_adjective, quantifier, function_call, role_name, value_constraint, literal, objectification_join)
+	    Compiler::VarRef.new(gt, leading_adjective, trailing_adjective, quantifier, function_call, role_name, value_constraint, literal, nested_clauses)
 	  end
 
 	  def value		# Sometimes we just want the full term name
             x.context[:term]
           end
+	  def node_type; :term; end
         }
 	/
 	s head:id '-' s term	&{|s| s[4].ast.leading_adjective == nil }
 	{
-	  def ast quantifier = nil, function_call = nil, role_name = nil, value_constraint = nil, literal = nil, objectification_join = nil
-	    ast = term.ast(quantifier, function_call, role_name, value_constraint, literal, objectification_join)
+	  def ast quantifier = nil, function_call = nil, role_name = nil, value_constraint = nil, literal = nil, nested_clauses = nil
+	    ast = term.ast(quantifier, function_call, role_name, value_constraint, literal, nested_clauses)
 	    ast.leading_adjective = head.text_value
 	    ast
 	  end
+	  def node_type; :term; end
 	}
       end
 
@@ -148,17 +176,19 @@ module ActiveFacts
         }
       end
 
-      rule non_role_word
-        # These words are illegal in (but maybe ok following) a reading where a role word is expected:
+      rule non_phrase
+        # These words are illegal in (but maybe ok following) a clause where a phrase is expected:
         and
-        / where
+        / but
         / if
+        / role_list_constraint_followers
         / only
         / or
         / quantifier
+        / returning
+        / then
         / value_constraint
-        / but
-	/ 'occurs' s quantifier s 'time' 
+        / where
       end
 
     end

data/lib/activefacts/cql/ValueTypes.treetop

@@ -9,25 +9,37 @@ module ActiveFacts
     grammar ValueTypes
       rule value_type
         s term_definition_name
+	m1:mapping_pragmas
 	# REVISIT: ORM2 would allow (subtype_prefix term)?
         written_as
-        base:(term/id) s
+        base:(term/implicit_value_type_name) s
         value_type_parameters
         u:units?
         r:(value_constraint enforcement)?
-        mapping_pragmas
+        m2:mapping_pragmas
         s ';' s
         {
 	  def ast
 	    name = term_definition_name.value
 	    params = value_type_parameters.values
-	    value_constraint = r.empty? ? nil : Compiler::ValueConstraint.new(r.value_constraint.ranges, r.enforcement.ast)
+	    value_constraint = nil
+	    unless r.empty? 
+	      value_constraint = Compiler::ValueConstraint.new(r.value_constraint.ranges, r.value_constraint.units, r.enforcement.ast)
+	    end
 	    units = u.empty? ? [] : u.value
-	    Compiler::ValueType.new name, base.value, params, units, value_constraint, mapping_pragmas.value
+	    pragmas = m1.value+m2.value
+	    Compiler::ValueType.new name, base.value, params, units, value_constraint, pragmas
 	  end
         }
       end
 
+      rule implicit_value_type_name
+	id
+	{
+	  def node_type; :term; end
+	}
+      end
+
       rule value_type_parameters
         '(' s tpl:type_parameter_list? ')' s
           { def values; tpl.empty? ? [] : tpl.values; end }
@@ -46,12 +58,12 @@ module ActiveFacts
 
       rule unit_definition
         u:(
-          coeff:unit_coefficient? base:units? s o:unit_offset?
-          converts s a:(approximately s)? to s
-          singular:id s plural:('/' s p:id s)?
+          s coeff:unit_coefficient? base:units? s o:unit_offset?
+	  conversion
+          singular:unit_name s plural:('/' s p:unit_name s)?
         /
-          singular:id s plural:('/' s p:id s)?
-          converts s a:(approximately s)? to s
+          s singular:unit_name s plural:('/' s p:unit_name s)?
+	  conversion
           coeff:unit_coefficient? base:units? s o:unit_offset?
         )
         q:(approximately '' / ephemera s url )? s
@@ -68,13 +80,21 @@ module ActiveFacts
 	    end
             offset = u.o.text_value.empty? ? 0 : u.o.value
 	    bases = u.base.empty? ? [] : u.base.value
-	    approximately = q.respond_to? :approximately
+	    approximately = q.respond_to?(:approximately) || u.conversion.approximate?
 	    ephemera = q.respond_to?(:ephemera) ? q.url.text_value : nil
 	    Compiler::Unit.new singular, plural, numerator, denominator, offset, bases, approximately, ephemera
 	  end
         }
       end
 
+      rule unit_name
+	id
+	{
+	  def node_type; :unit; end
+	}
+      end
+
+
       rule unit_coefficient
         numerator:number denominator:(s '/' s number)? s
         {
@@ -105,7 +125,7 @@ module ActiveFacts
       end
 
       rule non_unit
-        restricted / converts / approximately / ephemera
+        restricted / conversion / approximately / ephemera
       end
 
       rule unit
@@ -113,7 +133,7 @@ module ActiveFacts
       end
 
       rule maybe_unit
-        unit_name:id pow:('^' '-'? [0-9])?
+        unit_name pow:('^' '-'? [0-9])?
         { def value
             [unit_name.text_value, pow.text_value.empty? ? 1 : Integer(pow.text_value[1..-1])]
           end
@@ -129,12 +149,18 @@ module ActiveFacts
 	restricted s to s range_list s u:units?
         {
           def ranges
-	    raise "units on value constraints are not yet processed" unless u.empty? # REVISIT: Use the units here
             range_list.ranges
           end
+
+	  def units
+	    u.empty? ? nil : u.value
+	  end
         }
+	# REVISIT: "where the possible value/s of that <Term> is/are value (, ...)"
       end
 
+      # REVISIT: Value constraint for ValueType or EntityType&Refmode: "the possible values of <TYPE> are value (, ...)"
+
       rule range_list
         '{' s
           head:range s tail:( ',' s range )*

data/lib/activefacts/cql/compiler.rb

@@ -4,14 +4,15 @@
 #
 require 'activefacts/vocabulary'
 require 'activefacts/cql/parser'
-
 require 'activefacts/cql/compiler/shared'
 require 'activefacts/cql/compiler/value_type'
 require 'activefacts/cql/compiler/entity_type'
-require 'activefacts/cql/compiler/reading'
+require 'activefacts/cql/compiler/clause'
 require 'activefacts/cql/compiler/fact_type'
+require 'activefacts/cql/compiler/expression'
 require 'activefacts/cql/compiler/fact'
 require 'activefacts/cql/compiler/constraint'
+require 'activefacts/cql/compiler/join'
 
 module ActiveFacts
   module CQL
@@ -31,6 +32,7 @@ module ActiveFacts
           compile(f.read)
         end
         @filename = old_filename
+        @vocabulary
       end
 
       def compile input
@@ -43,7 +45,7 @@ module ActiveFacts
               ast = node.ast
               next unless ast
               debug :ast, ast.inspect
-              ast.source = node.body
+              ast.tree = node
               ast.constellation = @constellation
               ast.vocabulary = @vocabulary
               value = compile_definition ast

data/lib/activefacts/cql/compiler/{reading.rb → clause.rb}

@@ -2,88 +2,107 @@ module ActiveFacts
   module CQL
     class Compiler < ActiveFacts::CQL::Parser
 
-      class Reading
+      class Clause
         attr_reader :phrases
         attr_accessor :qualifiers, :context_note
-        attr_reader :fact_type, :reading, :role_sequence    # These are the Metamodel objects
-        attr_reader :side_effects
-        attr_writer :fact_type          # Assigned for a bare (existential) objectification fact
+        attr_accessor :conjunction      # one of {nil, 'and', ',', 'or', 'where'}
+        attr_accessor :fact_type
+        attr_reader :reading, :role_sequence    # These are the Metamodel objects
+        attr_reader :side_effects       # How to adjust the phrases if this fact_type match is accepted
         attr_accessor :fact             # When binding fact instances the fact goes here
-        attr_accessor :objectified_as   # The Reading::RoleRef which objectified this fact type
+        attr_accessor :objectified_as   # The VarRef which objectified this fact type
 
-        def initialize role_refs_and_words, qualifiers = [], context_note = nil
-          @phrases = role_refs_and_words
-          role_refs.each { |role_ref| role_ref.reading = self }
+        def initialize phrases, qualifiers = [], context_note = nil
+          @phrases = phrases
+          var_refs.each { |var_ref| var_ref.clause = self }
           @qualifiers = qualifiers
           @context_note = context_note
         end
 
-        def role_refs
-          @phrases.select{|r| r.is_a?(RoleRef)}
+        def var_refs
+          @phrases.select{|r| r.respond_to?(:player)}
         end
 
-        # A reading that contains only the name of a Concept and no literal or reading text
-        # refers only to the existence of that Concept (as opposed to an instance of the concept).
+        # A clause that contains only the name of a ObjectType and no literal or reading text
+        # refers only to the existence of that ObjectType (as opposed to an instance of the object_type).
         def is_existential_type
           @phrases.size == 1 and
-            @phrases[0].is_a?(RoleRef) and
+            @phrases[0].is_a?(VarRef) and
             !@phrases[0].literal
         end
 
         def display
+          to_s
+        end
+
+        def inspect
+          to_s
+        end
+
+        def to_s
           "#{
-            @qualifiers && @qualifiers.size > 0 ? @qualifiers.inspect+' ' : nil
+            @qualifiers && @qualifiers.size > 0 ? @qualifiers.sort.inspect+' ' : nil
           }#{
-            @phrases.map{|p| p.to_s }*" "
+            quotes = false
+            @phrases.inject(""){|s, p|
+              if String === p
+                s + (quotes ? '' : (quotes = true; '"')) + p.to_s + ' '
+#              REVISIT: Add something here when I re-add functions
+#              elsif FunctionCallChain === p
+#                s[0..-2] + (quotes ? (quotes = false; '" ') : '') + p.to_s
+              else # if VarRef === p
+                s[0..-2] + (quotes ? (quotes = false; '" ') : '') + p.to_s +
+                  ((oj = p.nested_clauses) ?  ' ('+ oj.map{|c| ((j=c.conjunction) ? j+' ' : '') + c.to_s}*' ' + ')' : '') +
+                ' '
+#              else
+#                raise "Unexpected phrase type in clause: #{p.to_s}"
+              end
+            }.sub(/ $/,'') + (quotes ? '"' : '')
           }#{
-            @context_note && ' '+@context_note.inspect
+            @context_note && ' ' + @context_note.inspect
           }"
         end
 
-        def inspect
-          "#{@qualifiers && @qualifiers.size > 0 ? @qualifiers.inspect+' ' : nil}#{@phrases.map{|p|p.inspect}*" "}#{@context_note && ' '+@context_note.inspect}"
-        end
-
         def identify_players_with_role_name context
-          role_refs.each do |role_ref|
-            role_ref.identify_player(context) if role_ref.role_name
-            # Include players in an objectification join, if any
-            role_ref.objectification_join.each{|reading| reading.identify_players_with_role_name(context)} if role_ref.objectification_join
+          var_refs.each do |var_ref|
+            var_ref.identify_players_with_role_name(context)
           end
         end
 
         def identify_other_players context
-          role_refs.each do |role_ref|
-            role_ref.identify_player(context) unless role_ref.player
-            # Include players in an objectification join, if any
-            role_ref.objectification_join.each{|reading| reading.identify_other_players(context)} if role_ref.objectification_join
+          var_refs.each do |var_ref|
+            var_ref.identify_other_players(context)
+            # Include players in nested clauses, if any
+            var_ref.nested_clauses.each{|clause| clause.identify_other_players(context)} if var_ref.nested_clauses
           end
         end
 
         def includes_literals
-          role_refs.detect{|role_ref| role_ref.literal || (ja = role_ref.objectification_join and ja.detect{|jr| jr.includes_literals })}
+          var_refs.detect{|var_ref| var_ref.literal || (ja = var_ref.nested_clauses and ja.detect{|jr| jr.includes_literals })}
         end
 
-        def bind_roles context
-          role_names = role_refs.map{ |role_ref| role_ref.role_name }.compact
+        def is_equality_comparison
+          false
+        end
 
-          # Check uniqueness of role names and subscripts within this reading:
+        def bind context
+          role_names = var_refs.map{ |var_ref| var_ref.role_name }.compact
+
+          # Check uniqueness of role names and subscripts within this clause:
           role_names.each do |rn|
             next if role_names.select{|rn2| rn2 == rn}.size == 1
-            raise "Duplicate role #{rn.is_a?(Integer) ? "subscript" : "name"} '#{rn}' in reading"
+            raise "Duplicate role #{rn.is_a?(Integer) ? "subscript" : "name"} '#{rn}' in clause"
           end
 
-          role_refs.each do |role_ref|
-            role_ref.bind context
-            # Include players in an objectification join, if any
-            role_ref.objectification_join.each{|reading| reading.bind_roles(context)} if role_ref.objectification_join
+          var_refs.each do |var_ref|
+            var_ref.bind context
           end
         end
 
         def phrases_match(phrases)
           @phrases.zip(phrases).each do |mine, theirs|
-            return false if mine.is_a?(RoleRef) != theirs.is_a?(RoleRef)
-            if mine.is_a?(RoleRef)
+            return false if mine.is_a?(VarRef) != theirs.is_a?(VarRef)
+            if mine.is_a?(VarRef)
               return false unless mine.key == theirs.key
             else
               return false unless mine == theirs
@@ -93,134 +112,170 @@ module ActiveFacts
         end
 
         # This method chooses the existing fact type which matches most closely.
-        # It returns nil if there is none, or a ReadingMatchSideEffects object if matched.
+        # It returns nil if there is none, or a ClauseMatchSideEffects object if matched.
         #
         # As this match may not necessarily be used (depending on the side effects),
-        # no change is made to this Reading object - those will be done later.
-        def match_existing_fact_type context
-          raise "Internal error, reading already matched, should not match again" if @fact_type
-          rrs = role_refs
-          players = rrs.map{|rr| rr.player}
-          raise "Must identify players before matching fact types" if players.include? nil
-          raise "A fact type must involve at least one object type, but there are none in '#{inspect}'" if players.size == 0
-
-          player_names = players.map{|p| p.name}
-
-          debug :matching, "Looking for existing #{players.size}-ary fact types matching '#{inspect}'" do
-            debug :matching, "Players are '#{player_names.inspect}'"
-
-            # Match existing fact types in objectification joins first:
-            rrs.each do |role_ref|
-              next unless joins = role_ref.objectification_join and !joins.empty?
-              role_ref.objectification_join.each do |oj|
-                ft = oj.match_existing_fact_type(context)
-                raise "Unrecognised fact type #{oj.display}" unless ft
-                if (ft && ft.entity_type == role_ref.player)
-                  role_ref.objectification_of = ft
-                  oj.objectified_as = role_ref
+        # no change is made to this Clause object - those will be done later.
+        #
+        def match_existing_fact_type context, options = {}
+          raise "Internal error, clause already matched, should not match again" if @fact_type
+          # If we fail to match, try to a left contraction (or save this for a subsequent left contraction):
+          left_contract_this_onto = context.left_contractable_clause
+          new_conjunction = (conjunction == nil || conjunction == ',')
+          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}"
+            context.left_contractable_clause = self
+            left_contract_this_onto = nil # Can't left-contract this clause
+          end
+          context.left_contraction_conjunction = new_conjunction ? nil : @conjunction
+
+          contracted_role = nil
+
+          vrs = []+var_refs
+          begin
+            players = vrs.map{|vr| vr.player}
+            raise "Must identify players before matching fact types" if players.include? nil
+            raise "A fact type must involve at least one object type, but there are none in '#{inspect}'" if players.size == 0 && !left_contract_this_onto
+
+            player_names = players.map{|p| p.name}
+
+            debug :matching, "Looking for existing #{players.size}-ary fact types matching '#{contracted_role && contracted_role.inspect+' '}#{inspect}'" do
+              debug :matching, "Players are '#{player_names.inspect}'"
+
+              # Match existing fact types in nested clauses first (not for contractions):
+              if !contracted_role
+                vrs.each do |var_ref|
+                  next if var_ref.is_a?(Operation)
+                  next unless joins = var_ref.nested_clauses and !joins.empty?
+                  var_ref.nested_clauses.each do |oj|
+                    ft = oj.match_existing_fact_type(context)
+                    raise "Unrecognised fact type #{oj.display}" unless ft
+                    if (ft && ft.entity_type == var_ref.player)
+                      var_ref.objectification_of = ft
+                      oj.objectified_as = var_ref
+                    end
+                  end
+                  raise "#{var_ref.inspect} contains objectification joins that do not objectify it" unless var_ref.objectification_of
                 end
               end
-              raise "#{role_ref.inspect} contains objectification joins that do not objectify it" unless role_ref.objectification_of
-            end
 
-            # For each role player, find the compatible types (the set of all subtypes and supertypes).
-            # For a player that's an objectification, we don't allow implicit supertype joins
-            player_related_types =
-              rrs.map do |role_ref|
-                player = role_ref.player
-                ((role_ref.objectification_of ? [] : player.supertypes_transitive) +
-                  player.subtypes_transitive).uniq
-              end
+              # For each role player, find the compatible types (the set of all subtypes and supertypes).
+              # For a player that's an objectification, we don't allow implicit supertype joins
+              player_related_types =
+                vrs.zip(players).map do |var_ref, player|
+                  disallow_subtyping = var_ref && var_ref.objectification_of || options[:exact_type]
+                  ((disallow_subtyping ? [] : player.supertypes_transitive) +
+                    player.subtypes_transitive).uniq
+                end
 
-            debug :matching, "Players must match '#{player_related_types.map{|pa| pa.map{|p|p.name}}.inspect}'"
-
-            # The candidate fact types have the right number of role players of related types.
-            # If any role is played by a supertype or subtype of the required type, there's an implicit subtyping join
-            candidate_fact_types =
-              player_related_types[0].map do |related_type|
-                related_type.all_role.select do |role|
-                  all_roles = role.fact_type.all_role
-                  next if all_roles.size != players.size      # Wrong number of players
-                  next if role.fact_type.is_a?(ActiveFacts::Metamodel::ImplicitFactType)
-
-                  all_players = all_roles.map{|r| r.concept}  # All the players of this candidate fact type
-
-                  next if player_related_types[1..-1].        # We know the first player is compatible, check the rest
-                    detect do |player_types|                  # Make sure that there remains a compatible player
-                      # player_types is an array of the types compatible with the Nth player
-                      compatible_player = nil
-                      all_players.each_with_index do |p, i|
-                        if player_types.include?(p)
-                          compatible_player = p
-                          all_players.delete_at(i)
-                          break
+              debug :matching, "Players must match '#{player_related_types.map{|pa| pa.map{|p|p.name}}.inspect}'"
+
+              # The candidate fact types have the right number of role players of related types.
+              # If any role is played by a supertype or subtype of the required type, there's an implicit subtyping join
+              candidate_fact_types =
+                player_related_types[0].map do |related_type|
+                  related_type.all_role.select do |role|
+                    all_roles = role.fact_type.all_role
+                    next if all_roles.size != players.size      # Wrong number of players
+                    next if role.fact_type.is_a?(ActiveFacts::Metamodel::ImplicitFactType)
+
+                    all_players = all_roles.map{|r| r.object_type}  # All the players of this candidate fact type
+
+                    next if player_related_types[1..-1].        # We know the first player is compatible, check the rest
+                      detect do |player_types|                  # Make sure that there remains a compatible player
+                        # player_types is an array of the types compatible with the Nth player
+                        compatible_player = nil
+                        all_players.each_with_index do |p, i|
+                          if player_types.include?(p)
+                            compatible_player = p
+                            all_players.delete_at(i)
+                            break
+                          end
                         end
+                        !compatible_player
                       end
-                      !compatible_player
-                    end
 
-                  true
-                end.
-                  map{ |role| role.fact_type}
-              end.flatten.uniq
+                    true
+                  end.
+                    map{ |role| role.fact_type}
+                end.flatten.uniq
 
-            # If there is more than one possible exact match (same adjectives) with different subyping, the implicit join is ambiguous and is not allowed
+              # If there is more than one possible exact match (same adjectives) with different subyping, the implicit join is ambiguous and is not allowed
 
-            debug :matching, "Looking amongst #{candidate_fact_types.size} existing fact types for one matching '#{inspect}'" do
-              matches = {}
-              candidate_fact_types.map do |fact_type|
-                fact_type.all_reading.map do |reading|
-                  next unless side_effects = reading_matches(fact_type, reading)
-                  matches[reading] = side_effects if side_effects
+              debug :matching, "Looking amongst #{candidate_fact_types.size} existing fact types for one matching '#{contracted_role && contracted_role.inspect+' '}#{inspect}'" do
+                matches = {}
+                candidate_fact_types.map do |fact_type|
+                  fact_type.all_reading.map do |reading|
+                    next unless side_effects = clause_matches(fact_type, reading, contracted_role)
+                    matches[reading] = side_effects if side_effects
+                  end
                 end
-              end
 
-              # REVISIT: Side effects that leave extra adjectives should only be allowed if the
-              # same extra adjectives exist in some other reading in the same declaration.
-              # The extra adjectives are then necessary to associate the two role players
-              # when consumed adjectives were required to bind to the underlying fact types.
-              # This requires the final decision on fact type matching to be postponed until
-              # the whole declaration has been processed and the extra adjectives can be matched.
-
-              best_matches = matches.keys.sort_by{|match|
-                # Between equivalents, prefer the one without a join 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 : ''}"
-
-              if matches.size > 1
-                first = matches[best_matches[0]]
-                cost = first.cost
-                equal_best = matches.select{|k,m| m.cost == cost}
+                # REVISIT: Side effects that leave extra adjectives should only be allowed if the
+                # same extra adjectives exist in some other clause in the same declaration.
+                # The extra adjectives are then necessary to associate the two role players
+                # when consumed adjectives were required to bind to the underlying fact types.
+                # This requires the final decision on fact type matching to be postponed until
+                # the whole declaration has been processed and the extra adjectives can be matched.
+
+                best_matches = matches.keys.sort_by{|match|
+                  # Between equivalents, prefer the one without a join 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 : ''}"
+
+                if matches.size > 1
+                  first = matches[best_matches[0]]
+                  cost = first.cost
+                  equal_best = matches.select{|k,m| m.cost == cost}
+
+                  if equal_best.size > 1 and equal_best.detect{|k,m| !m.fact_type.is_a?(Metamodel::TypeInheritance)}
+                    # Complain if there's more than one equivalent cost match (unless all are TypeInheritance):
+                    raise "#{@phrases.inspect} could match any of the following:\n\t"+
+                      best_matches.map { |reading| reading.expand + " with " + matches[reading].describe } * "\n\t"
+                  end
+                end
 
-                if equal_best.size > 1 and equal_best.detect{|k,m| !m.fact_type.is_a?(Metamodel::TypeInheritance)}
-                  # Complain if there's more than one equivalent cost match (unless all are TypeInheritance):
-                  raise "#{@phrases.inspect} could match any of the following:\n\t"+
-                    best_matches.map { |reading| reading.expand + " with " + matches[reading].describe } * "\n\t"
+                if matches.size >= 1
+                  @reading = best_matches[0]
+                  @side_effects = matches[@reading]
+                  @fact_type = @side_effects.fact_type
+                  debug :matching, "Matched '#{@fact_type.default_reading}'"
+                  @phrases.unshift(contracted_role) if contracted_role
+                  apply_side_effects(context, @side_effects)
+                  return @fact_type
                 end
-              end
 
-              if matches.size >= 1
-                @reading = best_matches[0]
-                @side_effects = matches[@reading]
-                @fact_type = @side_effects.fact_type
-                debug :matching, "Matched '#{@fact_type.default_reading}'"
-                apply_side_effects(context, @side_effects)
-                return @fact_type
               end
-
+              debug :matching, "No fact type matched, candidates were '#{candidate_fact_types.map{|ft| ft.default_reading}*"', '"}'"
+            end
+            if left_contract_this_onto && !contracted_role
+              contracted_from = left_contract_this_onto.var_refs[0]
+              contraction_player = contracted_from.player
+              contracted_role = VarRef.new(contraction_player.name)
+              contracted_role.player = contracted_from.player
+              contracted_role.role_name = contracted_from.role_name
+              contracted_role.bind(context)
+              vrs.unshift contracted_role
+
+              debug :matching, "Failed to match #{inspect}. Trying again using left contraction onto #{contraction_player.name}"
+              redo
             end
-            debug :matching, "No fact type matched, candidates were '#{candidate_fact_types.map{|ft| ft.default_reading}*"', '"}'"
+          end until true  # Once through, unless we hit a redo
+          if contracted_role
+            contracted_role.unbind context
           end
           @fact_type = nil
         end
 
-        # The ActiveFacts::Metamodel::Reading passed has the same players as this Compiler::Reading. Does it match?
+        # The Reading passed has the same players as this Clause. Does it match?
         # Twisty curves. This is a complex bit of code!
-        # Find whether the phrases of this reading match the fact type reading,
+        # Find whether the phrases of this clause match the fact type reading,
         # which may require absorbing unmarked adjectives.
         #
-        # If it does match, make the required changes and set @role_ref to the matching role.
+        # If it does match, make the required changes and set @var_ref to the matching role ref.
         # Adjectives that were used to match are removed (and leaving any additional adjectives intact).
         #
         # Approach:
@@ -233,20 +288,19 @@ module ActiveFacts
         #       trailing adjectives, both marked and unmarked, are absorbed too.
         #     a word that matches the reading's
         #
-        def reading_matches(fact_type, reading)
+        def clause_matches(fact_type, reading, contracted_role = nil)
           side_effects = []    # An array of items for each role, describing any side-effects of the match.
           intervening_words = nil
           residual_adjectives = false
-          debug :matching_fails, "Does '#{@phrases.inspect}' match '#{reading.expand}'" do
+          phrases = [contracted_role].compact+@phrases
+          debug :matching_fails, "Does '#{phrases.inspect}' match '#{reading.expand}'" do
             phrase_num = 0
             reading_parts = reading.text.split(/\s+/)
-            # Check that the number of roles matches (skipped, the caller should have done it):
-            # return nil unless reading_parts.select{|p| p =~ /\{(\d+)\}/}.size == role_refs.size
             reading_parts.each do |element|
               if element !~ /\{(\d+)\}/
                 # Just a word; it must match
-                unless @phrases[phrase_num] == element
-                  debug :matching_fails, "Mismatched ordinary word #{@phrases[phrase_num].inspect} (wanted #{element})"
+                unless phrases[phrase_num] == element
+                  debug :matching_fails, "Mismatched ordinary word #{phrases[phrase_num].inspect} (wanted #{element})"
                   return nil
                 end
                 phrase_num += 1
@@ -255,12 +309,14 @@ module ActiveFacts
                 role_ref = reading.role_sequence.all_role_ref.sort_by{|rr| rr.ordinal}[$1.to_i]
               end
 
+              player = role_ref.role.object_type
+
               # Figure out what's next in this phrase (the next player and the words leading up to it)
               next_player_phrase = nil
               intervening_words = []
-              while (phrase = @phrases[phrase_num])
+              while (phrase = phrases[phrase_num])
                 phrase_num += 1
-                if phrase.is_a?(RoleRef)
+                if phrase.respond_to?(:player)
                   next_player_phrase = phrase
                   next_player_phrase_num = phrase_num-1
                   break
@@ -268,21 +324,24 @@ module ActiveFacts
                   intervening_words << phrase
                 end
               end
-
-              player = role_ref.role.concept
               return nil unless next_player_phrase  # reading has more players than we do.
+              next_player = next_player_phrase.player
 
               # The next player must match:
               common_supertype = nil
-              if next_player_phrase.player != player
+              if next_player != player
                 # This relies on the supertypes being in breadth-first order:
-                common_supertype = (next_player_phrase.player.supertypes_transitive & player.supertypes_transitive)[0]
+                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_phrase.player.name}"
+                  debug :matching_fails, "Reading discounted because next player #{player.name} doesn't match #{next_player.name}"
                   return nil
                 end
 
                 debug :matching_fails, "Subtype join 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
+                end
               end
 
               # It's the right player. Do the adjectives match? This must include the intervening_words, if any.
@@ -316,12 +375,14 @@ module ActiveFacts
                 phrase_ta = (next_player_phrase.trailing_adjective||'').split(/\s+/)
                 i = 0   # Pad the phrases up to the size of the trailing_adjectives
                 while phrase_ta.size < ta.size
-                  break unless (word = @phrases[phrase_num+i]).is_a?(String)
+                  break unless (word = phrases[phrase_num+i]).is_a?(String)
                   phrase_ta << word
                   i += 1
                 end
+                # ta is the adjectives in the fact type being matched
+                # phrase_ta is the explicit adjectives augmented with implicit ones to the same size
                 return nil if ta != phrase_ta[0,ta.size]
-                role_has_residual_adjectives = true if phrase_ta.size > ta.size || i < ta.size
+                role_has_residual_adjectives = true if phrase_ta.size > ta.size
                 absorbed_followers = i
                 phrase_num += i # Skip following words that were consumed as trailing adjectives
               elsif next_player_phrase.trailing_adjective
@@ -330,7 +391,7 @@ module ActiveFacts
 
               # REVISIT: I'm not even sure I should be caring about role names here.
               # Role names are on roles, and are only useful within the fact type definition.
-              # At some point, we need to worry about role names on readings within fact type derivations,
+              # At some point, we need to worry about role names on clauses within fact type derivations,
               # which means they'll move to the Role Ref class; but even then they only match within the
               # definition that creates that Role Ref.
 =begin
@@ -343,24 +404,25 @@ module ActiveFacts
 =end
 
               residual_adjectives ||= role_has_residual_adjectives
-              if residual_adjectives && next_player_phrase.binding.refs.size == 1
+              if residual_adjectives && next_player_phrase.variable.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"
                 return nil
               end
 
               # The phrases matched this reading's next role_ref, save data to apply the side-effects:
-              debug :matching_fails, "Saving side effects for #{next_player_phrase.term}, absorbs #{absorbed_precursors}/#{absorbed_followers}#{common_supertype ? ', join over supertype '+ common_supertype.name : ''}" if absorbed_precursors+absorbed_followers+(common_supertype ? 1 : 0) > 0
-              side_effects << ReadingMatchSideEffect.new(next_player_phrase, role_ref, next_player_phrase_num, absorbed_precursors, absorbed_followers, common_supertype, role_has_residual_adjectives)
+              side_effects << ClauseMatchSideEffect.new(next_player_phrase, role_ref, next_player_phrase_num, absorbed_precursors, absorbed_followers, common_supertype, role_has_residual_adjectives)
             end
 
-            if phrase_num != @phrases.size || !intervening_words.empty?
-              debug :matching_fails, "Extra words #{(intervening_words + @phrases[phrase_num..-1]).inspect}"
+            if phrase_num != phrases.size || !intervening_words.empty?
+              debug :matching_fails, "Extra words #{(intervening_words + phrases[phrase_num..-1]).inspect}"
               return nil
             end
 
             if fact_type.is_a?(Metamodel::TypeInheritance)
               # There may be only one subtyping join on a TypeInheritance fact type.
-              ti_joins = side_effects.select{|se| se.common_supertype}
+              ti_joins = side_effects.select{|side_effect| side_effect.common_supertype}
               if ti_joins.size > 1   # Not allowed
                 debug :matching_fails, "Can't have more than one subtyping join on a TypeInheritance fact type"
                 return nil
@@ -368,7 +430,7 @@ module ActiveFacts
 
               if ti = ti_joins[0]
                 # The Type Inheritance join must continue in the same direction as this reading.
-                allowed = fact_type.supertype == ti.role_ref.role.concept ?
+                allowed = fact_type.supertype == ti.role_ref.role.object_type ?
                     fact_type.subtype.supertypes_transitive :
                     fact_type.supertype.subtypes_transitive
                 if !allowed.include?(ti.common_supertype)
@@ -378,11 +440,14 @@ module ActiveFacts
               end
             end
 
-            debug :matching, "Matched reading '#{reading.expand}' with #{side_effects.map{|se| se.absorbed_precursors+se.absorbed_followers + (se.common_supertype ? 1 : 0)
-            }.inspect} side effects#{residual_adjectives ? ' and residual adjectives' : ''}"
+            debug :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
+                } side effects)#{residual_adjectives ? ' and residual adjectives' : ''}"
           end
           # There will be one side_effects for each role player
-          ReadingMatchSideEffects.new(fact_type, self, residual_adjectives, side_effects)
+          ClauseMatchSideEffects.new(fact_type, self, residual_adjectives, side_effects)
         end
 
         def apply_side_effects(context, side_effects)
@@ -390,68 +455,71 @@ module ActiveFacts
           # 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
-            side_effects.apply_all do |se|
+            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 join, etc).
-              debug :matching, "side-effect means binding #{se.phrase.inspect} matches role ref #{se.role_ref.role.concept.name}"
-              se.phrase.role_ref = se.role_ref
+              debug :matching, "side-effect means variable #{phrase.inspect} matches role ref #{side_effect.role_ref.role.object_type.name}"
+              phrase.role_ref = side_effect.role_ref
 
               changed = false
 
               # Where this phrase has leading or trailing adjectives that are in excess of those of
               # the role_ref, those must be local, and we'll need to extract them.
 
-              if rra = se.role_ref.trailing_adjective
-                debug :matching, "Deleting matched trailing adjective '#{rra}'#{se.absorbed_followers>0 ? " in #{se.absorbed_followers} followers" : ""}"
+              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" : ""}"
 
                 # These adjective(s) matched either an adjective here, or a follower word, or both.
-                if a = se.phrase.trailing_adjective
+                if a = phrase.trailing_adjective
                   if a.size >= rra.size
-                    a.slice!(0, rra.size+1) # Remove the matched adjectives and the space (if any)
-                    se.phrase.wipe_trailing_adjective if a.empty?
+                    a = a[rra.size+1..-1]
+                    phrase.trailing_adjective = a == '' ? nil : a
                     changed = true
                   end
-                elsif se.absorbed_followers > 0
-                  se.phrase.wipe_trailing_adjective
-                  # This phrase is absorbing non-hyphenated adjective(s), which changes its binding
-                  se.phrase.trailing_adjective = @phrases.slice!(se.num+1, se.absorbed_followers)*' '
-                  se.phrase.rebind context
+                elsif side_effect.absorbed_followers > 0
+                  # The following statement is incorrect. The absorbed adjective is what caused the match.
+                  # This phrase is absorbing non-hyphenated adjective(s), which changes its variable
+                  # phrase.trailing_adjective =
+                  @phrases.slice!(side_effect.num+1, side_effect.absorbed_followers)*' '
                   changed = true
                 end
               end
 
-              if rra = se.role_ref.leading_adjective
-                debug :matching, "Deleting matched leading adjective '#{rra}'#{se.absorbed_precursors>0 ? " in #{se.absorbed_precursors} precursors" : ""}}"
+              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" : ""}}"
 
                 # These adjective(s) matched either an adjective here, or a precursor word, or both.
-                if a = se.phrase.leading_adjective
+                if a = phrase.leading_adjective
                   if a.size >= rra.size
-                    a.slice!(-rra.size, 1000) # Remove the matched adjectives and the space
-                    a.chop!
-                    se.phrase.wipe_leading_adjective if a.empty?
+                    a = a[0...-rra.size]
+                    phrase.leading_adjective = a == '' ? nil : a
                     changed = true
                   end
-                elsif se.absorbed_precursors > 0
-                  se.phrase.wipe_leading_adjective
-                  # This phrase is absorbing non-hyphenated adjective(s), which changes its binding
-                  se.phrase.leading_adjective = @phrases.slice!(se.num-se.absorbed_precursors, se.absorbed_precursors)*' '
-                  se.phrase.rebind context
+                elsif side_effect.absorbed_precursors > 0
+                  # The following statement is incorrect. The absorbed adjective is what caused the match.
+                  # This phrase is absorbing non-hyphenated adjective(s), which changes its variable
+                  #phrase.leading_adjective =
+                  @phrases.slice!(side_effect.num-side_effect.absorbed_precursors, side_effect.absorbed_precursors)*' '
                   changed = true
                 end
               end
+              if changed
+                phrase.rebind context
+              end
 
             end
           end
         end
 
-        # Make a new fact type with roles for this reading.
+        # Make a new fact type with roles for this clause.
         # 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
             @phrases.each do |phrase|
-              next unless phrase.is_a?(RoleRef)
-              phrase.role = vocabulary.constellation.Role(fact_type, fact_type.all_role.size, :concept => phrase.player)
+              next unless phrase.respond_to?(:player)
+              phrase.role = vocabulary.constellation.Role(fact_type, fact_type.all_role.size, :object_type => phrase.player)
               phrase.role.role_name = phrase.role_name if phrase.role_name && phrase.role_name.is_a?(String)
             end
           end
@@ -466,12 +534,12 @@ module ActiveFacts
           index = 0
           debug :matching, "Making new reading for #{@phrases.inspect}" do
             reading_words.map! do |phrase|
-              if phrase.is_a?(RoleRef)
+              if phrase.respond_to?(:player)
                 # phrase.role will be set if this reading was used to make_fact_type.
-                # Otherwise we have to find the existing role via the Binding. This is pretty ugly.
+                # Otherwise we have to find the existing role via the Variable. This is pretty ugly.
                 unless phrase.role
-                  # Find another binding for this phrase which already has a role_ref to the same fact type:
-                  ref = phrase.binding.refs.detect{|ref| ref.role_ref && ref.role_ref.role.fact_type == fact_type}
+                  # Find another variable for this phrase which already has a role_ref to the same fact type:
+                  ref = phrase.variable.refs.detect{|ref| ref.role_ref && ref.role_ref.role.fact_type == fact_type}
                   role_ref = ref.role_ref
                   phrase.role = role_ref.role
                 end
@@ -500,10 +568,11 @@ module ActiveFacts
             end
             if existing = @fact_type.all_reading.detect{|r|
                 r.text == reading_words*' ' and
-                  r.role_sequence.all_role_ref_in_order.map{|rr| rr.role.concept} ==
-                    role_sequence.all_role_ref_in_order.map{|rr| rr.role.concept}
+                  r.role_sequence.all_role_ref_in_order.map{|rr| rr.role.object_type} ==
+                    role_sequence.all_role_ref_in_order.map{|rr| rr.role.object_type}
               }
-              raise "Reading '#{existing.expand}' already exists, so why are we creating a duplicate?"
+              existing
+              #raise "Reading '#{existing.expand}' already exists, so why are we creating a duplicate?"
             end
             constellation.Reading(@fact_type, @fact_type.all_reading.size, :role_sequence => @role_sequence, :text => reading_words*" ")
           end
@@ -520,13 +589,13 @@ module ActiveFacts
           reading_words = []
           new_role_sequence_needed = false
           @phrases.each do |phrase|
-            if phrase.is_a?(RoleRef)
+            if phrase.respond_to?(:player)
               role_phrases << phrase
               reading_words << "{#{phrase.role_ref.ordinal}}"
-              if phrase.role_name # ||
-#                  phrase.leading_adjective ||
-#                  phrase.trailing_adjective
-                debug :matching, "phrase in matched reading has residual adjectives or role name, so needs a new role_sequence" if @fact_type.all_reading.size > 0
+              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
                 new_role_sequence_needed = true
               end
             else
@@ -535,7 +604,7 @@ module ActiveFacts
             end
           end
 
-          debug :matching, "Reading '#{reading_words*' '}' #{new_role_sequence_needed ? 'requires' : 'does not require'} a new Role Sequence"
+          debug :matching, "Clause '#{reading_words*' '}' #{new_role_sequence_needed ? 'requires' : 'does not require'} a new Role Sequence"
 
           constellation = @fact_type.constellation
           reading_text = reading_words*" "
@@ -568,37 +637,53 @@ module ActiveFacts
               debug :matching, "Using existing role sequence for new reading '#{reading_text}'"
             end
           end
-          if @fact_type.all_reading.detect{|r| r.text == reading_text}
-            raise "Reading '#{@reading.expand}' already exists, so why are we creating a duplicate (with #{extra_adjectives.inspect})?"
+          if @fact_type.all_reading.
+            detect do |r|
+              r.text == reading_text and
+              r.role_sequence.all_role_ref_in_order.map{|rr| rr.role.object_type} ==
+                @role_sequence.all_role_ref_in_order.map{|rr| rr.role.object_type}
+            end
+            # raise "Reading '#{@reading.expand}' already exists, so why are we creating a duplicate (with #{extra_adjectives.inspect})?"
+          else
+            constellation.Reading(@fact_type, @fact_type.all_reading.size, :role_sequence => @role_sequence, :text => reading_text)
           end
-          constellation.Reading(@fact_type, @fact_type.all_reading.size, :role_sequence => @role_sequence, :text => reading_text)
           @role_sequence
         end
 
         def make_embedded_constraints vocabulary
-          role_refs.each do |role_ref|
-            next unless role_ref.quantifier
-            # puts "Quantifier #{role_ref.inspect} not implemented as a presence constraint"
-            role_ref.make_embedded_presence_constraint vocabulary
+          var_refs.each do |var_ref|
+            next unless var_ref.quantifier
+            # puts "Quantifier #{var_ref.inspect} not implemented as a presence constraint"
+            var_ref.make_embedded_presence_constraint vocabulary
           end
 
           if @qualifiers && @qualifiers.size > 0
-
-            rc = RingConstraint.new(@role_sequence, @qualifiers)
-            rc.vocabulary = vocabulary
-            rc.constellation = vocabulary.constellation
-            rc.compile
+            # We shouldn't make a new ring constraint if there's already one over this ring.
+            existing_rcs = 
+              @role_sequence.all_role_ref.map{|rr| rr.role.all_ring_constraint.to_a }.flatten.uniq
+            unless existing_rcs[0]
+              rc = RingConstraint.new(@role_sequence, @qualifiers)
+              rc.vocabulary = vocabulary
+              rc.constellation = vocabulary.constellation
+              rc.compile
+            else
+              # Ignore the fact that the ring might be of a different type.
+            end
 
             # REVISIT: Check maybe and other qualifiers:
             debug :constraint, "Need to make constraints for #{@qualifiers*', '}" if @qualifiers.size > 0
           end
         end
 
+        def is_naked_object_type
+          @phrases.size == 1 && var_refs.size == 1
+        end
+
       end
 
-      # An instance of ReadingMatchSideEffects is created when the compiler matches an existing fact type.
+      # An instance of ClauseMatchSideEffects is created when the compiler matches an existing fact type.
       # It captures the details that have to be adjusted for the match to be regarded a success.
-      class ReadingMatchSideEffect
+      class ClauseMatchSideEffect
         attr_reader :phrase, :role_ref, :num, :absorbed_precursors, :absorbed_followers, :common_supertype, :residual_adjectives
 
         def initialize phrase, role_ref, num, absorbed_precursors, absorbed_followers, common_supertype, residual_adjectives
@@ -609,62 +694,73 @@ module ActiveFacts
           @absorbed_followers = absorbed_followers
           @common_supertype = common_supertype
           @residual_adjectives = residual_adjectives
+          debug :matching_fails, "Saving side effects for #{@phrase.term}, absorbs #{@absorbed_precursors}/#{@absorbed_followers}#{@common_supertype ? ', join over supertype '+ @common_supertype.name : ''}" if @absorbed_precursors+@absorbed_followers+(@common_supertype ? 1 : 0) > 0
         end
 
         def cost
           absorbed_precursors + absorbed_followers + (common_supertype ? 1 : 0)
         end
+
+        def to_s
+          "#{@phrase.inspect} absorbs #{@absorbed_precursors||0}/#{@absorbed_followers||0} at #{@num}#{@common_supertype && ' super '+@common_supertype.name}#{@residual_adjectives ? ' with residual adjectives' : ''}"
+        end
       end
 
-      class ReadingMatchSideEffects
+      class ClauseMatchSideEffects
         attr_reader :residual_adjectives
         attr_reader :fact_type
-        attr_reader :role_side_effects    # One array of values per RoleRef matched, in order
+        attr_reader :role_side_effects    # One array of values per VarRef matched, in order
 
-        def initialize fact_type, reading, residual_adjectives, role_side_effects
+        def initialize fact_type, clause, residual_adjectives, role_side_effects
           @fact_type = fact_type
-          @reading = reading
+          @clause = clause
           @residual_adjectives = residual_adjectives
           @role_side_effects = role_side_effects
         end
 
+        def to_s
+          'side-effects are [' +
+            @role_side_effects.map{|r| r.to_s}*', ' +
+            ']' +
+            "#{@residual_adjectives ? ' with residual adjectives' : ''}"
+        end
+
         def apply_all &b
           @role_side_effects.reverse.each{ |role_side_effect| b.call(*role_side_effect) }
         end
 
         def cost
           c = 0
-          @role_side_effects.each do |se|
-            c += se.cost
+          @role_side_effects.each do |side_effect|
+            c += side_effect.cost
           end
           c + (@residual_adjectives ? 1 : 0)
         end
 
         def describe
           actual_effects =
-            @role_side_effects.map do |se|
-              ( [se.common_supertype ? "supertype join over #{se.common_supertype.name}" : nil] +
-                [se.absorbed_precursors > 0 ? "absorbs #{se.absorbed_precursors} preceding words" : nil] +
-                [se.absorbed_followers > 0 ? "absorbs #{se.absorbed_followers} following words" : nil]
+            @role_side_effects.map do |side_effect|
+              ( [side_effect.common_supertype ? "supertype join over #{side_effect.common_supertype.name}" : nil] +
+                [side_effect.absorbed_precursors > 0 ? "absorbs #{side_effect.absorbed_precursors} preceding words" : nil] +
+                [side_effect.absorbed_followers > 0 ? "absorbs #{side_effect.absorbed_followers} following words" : nil]
               )
             end.flatten.compact*','
           actual_effects.empty? ? "no side effects" : actual_effects
         end
       end
 
-      class RoleRef
-        attr_reader :term, :leading_adjective, :trailing_adjective, :quantifier, :function_call, :role_name, :value_constraint, :literal, :objectification_join
-        attr_reader :player
-        attr_accessor :binding
-        attr_accessor :reading    # The reading that this RoleRef is part of
-        attr_accessor :role       # This refers to the ActiveFacts::Metamodel::Role
-        attr_accessor :role_ref   # This refers to the ActiveFacts::Metamodel::RoleRef
-        attr_accessor :objectification_of # If objectification_join is set, this is the fact type it objectifies
+      class VarRef
+        attr_reader :term, :quantifier, :function_call, :value_constraint, :literal, :nested_clauses
+        attr_accessor :leading_adjective, :trailing_adjective, :role_name
+        attr_accessor :player     # What ObjectType does the Variable denote
+        attr_accessor :variable   # What Variable for that ObjectType
+        attr_accessor :role       # Which Role of this ObjectType
+        attr_accessor :role_ref   # Which RoleRef to that Role
+        attr_accessor :clause     # The clause that this VarRef is part of
+        attr_accessor :objectification_of # If nested_clauses is set, this is the fact type it objectifies
         attr_reader :embedded_presence_constraint   # This refers to the ActiveFacts::Metamodel::PresenceConstraint
-        attr_writer :leading_adjective
-        attr_writer :role_name    # For assigning subscript when found in identifying roles list
 
-        def initialize term, leading_adjective = nil, trailing_adjective = nil, quantifier = nil, function_call = nil, role_name = nil, value_constraint = nil, literal = nil, objectification_join = nil
+        def initialize term, leading_adjective = nil, trailing_adjective = nil, quantifier = nil, function_call = nil, role_name = nil, value_constraint = nil, literal = nil, nested_clauses = nil
           @term = term
           @leading_adjective = leading_adjective
           @trailing_adjective = trailing_adjective
@@ -673,31 +769,29 @@ module ActiveFacts
           @role_name = role_name
           @value_constraint = value_constraint
           @literal = literal
-          @objectification_join = objectification_join
+          @nested_clauses = nested_clauses
         end
 
         def inspect
-          "RoleRef<#{
-            @quantifier && @quantifier.inspect+' ' }#{
-            @leading_adjective && @leading_adjective.sub(/ |$/,'- ').sub(/ *$/,' ') }#{
-            @term }#{
-            @trailing_adjective && ' '+@trailing_adjective.sub(/(.* |^)/, '\1-') }#{
-            @role_name and @role_name.is_a?(Integer) ? "(#{@role_name})" : " (as #{@role_name})" }#{
-            @literal && ' '+@literal.inspect }#{
-            @value_constraint && ' '+@value_constraint.inspect
-            }#{
-            @objectification_join ? "(where #{@objectification_join.inspect})" : ""
-          }>"
+          to_s
         end
 
         def to_s
-          "#{
-            @quantifier && @quantifier.inspect+' ' }#{
-            @leading_adjective && @leading_adjective.sub(/ |$/,'- ').sub(/ *$/,' ') }#{
-            @role_name || @term }#{
-            @trailing_adjective && ' '+@trailing_adjective.sub(/(.* |^)/, '\1-') }#{
-            @literal && ' '+@literal.inspect }#{
-            @value_constraint && ' '+@value_constraint.inspect }"
+          "{#{
+            @quantifier && @quantifier.inspect+' '
+          }#{
+            @leading_adjective && @leading_adjective.sub(/ |$/,'- ').sub(/ *$/,' ')
+          }#{
+            @term
+          }#{
+            @trailing_adjective && ' '+@trailing_adjective.sub(/(.* |^)/, '\1-')
+          }#{
+            @role_name and @role_name.is_a?(Integer) ? "(#{@role_name})" : " (as #{@role_name})"
+          }#{
+            @literal && ' '+@literal.inspect
+          }#{
+            @value_constraint && ' '+@value_constraint.to_s
+          }}"
         end
 
         def <=>(other)
@@ -707,11 +801,32 @@ module ActiveFacts
           ) <=> 0
         end
 
+        def includes_literals
+          @nested_clauses && @nested_clauses.detect{|oj| oj.includes_literals}
+        end
+
+        # We create value types for the results of arithmetic expressions, and they get assigned here:
+        def player=(player)
+          @player = player
+        end
+
+        def identify_players_with_role_name(context)
+          identify_player(context) if role_name
+          # Include players in nested clauses, if any
+          nested_clauses.each{|clause| clause.identify_players_with_role_name(context)} if nested_clauses
+        end
+
+        def identify_other_players context
+          identify_player context
+        end
+
         def identify_player context
-          @player = context.concept @term
-          raise "Concept #{@term} unrecognised" unless @player
-          context.player_by_role_name[@role_name] = player if @role_name
-          @player
+          @player || begin
+            @player = context.object_type @term
+            raise "ObjectType #{@term} unrecognised" unless @player
+            context.player_by_role_name[@role_name] = player if @role_name
+            @player
+          end
         end
 
         def uses_role_name?
@@ -732,6 +847,7 @@ module ActiveFacts
         end
 
         def bind context
+          @nested_clauses.each{|c| c.bind context} if @nested_clauses
           if role_name = @role_name
             # Omit these tests to see if anything evil eventuates:
             #if @leading_adjective || @trailing_adjective
@@ -745,19 +861,19 @@ module ActiveFacts
               role_name = @term
             end
           end
-          @binding = (context.bindings[key] ||= Binding.new(@player, role_name))
-          @binding.refs << self
-          @binding
+          @variable = (context.variables[key] ||= Variable.new(@player, role_name))
+          @variable.refs << self
+          @variable
         end
 
         def unbind context
           # The key has changed.
-          @binding.refs.delete(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 }
+          @variable.refs.delete(self)
+          if @variable.refs.empty?
+            # Remove the variable from the context if this was the last reference
+            context.variables.delete_if {|k,v| v == @variable }
           end
-          @binding = nil
+          @variable = nil
         end
 
         def rebind(context)
@@ -765,18 +881,18 @@ module ActiveFacts
           bind context
         end
 
-        def rebind_to(context, other_role_ref)
-          debug :binding, "Rebinding #{inspect} to #{other_role_ref.inspect}"
+        def rebind_to(context, other_var_ref)
+          debug :binding, "Rebinding #{inspect} to #{other_var_ref.inspect}"
 
-          old_binding = binding   # Remember to move all refs across
+          old_variable = variable   # Remember to move all refs across
           unbind(context)
 
-          new_binding = other_role_ref.binding
-          [self, *old_binding.refs].each do |ref|
-            ref.binding = new_binding
-            new_binding.refs << ref
+          new_variable = other_var_ref.variable
+          [self, *old_variable.refs].each do |ref|
+            ref.variable = new_variable
+            new_variable.refs << ref
           end
-          old_binding.rebound_to = new_binding
+          old_variable.rebound_to = new_variable
         end
 
         # These are called when we successfully match a fact type reading that has relevant adjectives:
@@ -804,9 +920,9 @@ module ActiveFacts
           fact_type = @role_ref.role.fact_type
           constellation = vocabulary.constellation
 
-          debug :constraint, "Processing embedded constraint #{@quantifier.inspect} on #{@role_ref.role.concept.name} in #{fact_type.describe}" do
-            # Preserve the role order of the reading, excluding this role:
-            constrained_roles = (@reading.role_refs-[self]).map{|rr| rr.role_ref.role}
+          debug :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.var_refs-[self]).map{|vr| vr.role_ref.role}
             if constrained_roles.empty?
               debug :constraint, "Quantifier over unary role has no effect"
               return
@@ -816,6 +932,8 @@ module ActiveFacts
               debug :constraint, "Setting max frequency to #{@quantifier.max} for existing constraint #{constraint.object_id} over #{constraint.role_sequence.describe} in #{fact_type.describe}"
               raise "Conflicting maximum frequency for constraint" if constraint.max_frequency && constraint.max_frequency != @quantifier.max
               constraint.max_frequency = @quantifier.max
+              raise "Conflicting minimum frequency for constraint" if constraint.min_frequency && constraint.min_frequency != @quantifier.min
+              constraint.min_frequency = @quantifier.min
             else
               role_sequence = constellation.RoleSequence(:new)
               constrained_roles.each_with_index do |constrained_role, i|
@@ -837,6 +955,10 @@ module ActiveFacts
           end
 
         end
+
+        def result(context = nil)
+          self
+        end
       end
 
       class Quantifier