bud 0.9.6 → 0.9.7

data/lib/bud/executor/elements.rb

@@ -17,10 +17,10 @@ module Bud
     def initialize(name_in, bud_instance, collection_name=nil, given_schema=nil, defer_schema=false, &blk)
       super(name_in, bud_instance, given_schema, defer_schema)
       @blk = blk
-      @outputs = []
-      @pendings = []
-      @deletes = []
-      @delete_keys = []
+      @outputs = Set.new
+      @pendings = Set.new
+      @deletes = Set.new
+      @delete_keys = Set.new
       @wired_by = []
       @elem_name = name_in
       @found_delta = false
@@ -114,8 +114,6 @@ module Bud
     end
 
     def push_out(item, do_block=true)
-      return if item.nil?
-
       if do_block && @blk
         item = item.to_a if @blk.arity > 1
         item = @blk.call item
@@ -151,18 +149,17 @@ module Bud
     # default for stateless elements
     public
     def add_rescan_invalidate(rescan, invalidate)
-      # if any of the source elements are in rescan mode, then put this node in
-      # rescan.
+      # If any sources are in rescan mode, then put this node in rescan
       srcs = non_temporal_predecessors
       if srcs.any?{|p| rescan.member? p}
         rescan << self
       end
 
-      # pass the current state to the non-element outputs, and see if they end
-      # up marking this node for rescan
+      # Pass the current state to each output collection and see if they end up
+      # marking this node for rescan
       invalidate_tables(rescan, invalidate)
 
-      # finally, if this node is in rescan, pass the request on to all source
+      # Finally, if this node is in rescan, pass the request on to all source
       # elements
       if rescan.member? self
         rescan.merge(srcs)
@@ -170,14 +167,16 @@ module Bud
     end
 
     def invalidate_tables(rescan, invalidate)
-      # exchange rescan and invalidate information with tables. If this node is
-      # in rescan, it may invalidate a target table (if it is a scratch). And if
-      # the target node is invalidated, this node marks itself for rescan to
-      # enable a refill of that table at run-time
-      @outputs.each do |o|
-        unless o.class <= PushElement
-          o.add_rescan_invalidate(rescan, invalidate)
-          rescan << self if invalidate.member? o
+      # Exchange rescan and invalidate information with tables. If this node is
+      # in rescan, it may invalidate an output table (if it is a scratch). And
+      # if the output table is going to be invalidated, this node marks itself
+      # for rescan to enable a refill of that table at run-time.
+      [@outputs, @pendings].each do |v|
+        v.each do |o|
+          unless o.class <= PushElement
+            o.add_rescan_invalidate(rescan, invalidate)
+            rescan << self if invalidate.member? o
+          end
         end
       end
     end
@@ -211,9 +210,8 @@ module Bud
 
     alias each pro
 
-    # XXX: "the_name" & "the_schema" parameters are unused
     public
-    def each_with_index(the_name=elem_name, the_schema=schema, &blk)
+    def each_with_index(&blk)
       toplevel = @bud_instance.toplevel
       elem = Bud::PushEachWithIndex.new("each_with_index#{object_id}",
                                         toplevel.this_rule_context,
@@ -255,6 +253,7 @@ module Bud
       end
     end
     alias <= merge
+
     superator "<~" do |o|
       raise Bud::Error, "illegal use of <~ with pusher '#{tabname}' on left"
     end
@@ -269,7 +268,7 @@ module Bud
 
     def group(keycols, *aggpairs, &blk)
       # establish schema
-      keycols = [] if keycols.nil?
+      keycols ||= []
       keycols = keycols.map{|c| canonicalize_col(c)}
       keynames = keycols.map{|k| k[2]}
       aggcolsdups = aggpairs.map{|ap| ap[0].class.name.split("::").last}
@@ -293,18 +292,15 @@ module Bud
     end
 
     def argagg(aggname, gbkey_cols, collection, &blk)
+      gbkey_cols ||= []
       gbkey_cols = gbkey_cols.map{|c| canonicalize_col(c)}
       collection = canonicalize_col(collection)
       toplevel = @bud_instance.toplevel
       agg = toplevel.send(aggname, collection)[0]
-      raise Bud::Error, "#{aggname} not declared exemplary" unless agg.class <= Bud::ArgExemplary
-      keynames = gbkey_cols.map do |k|
-        if k.class == Symbol
-          k.to_s
-        else
-          k[2]
-        end
+      unless agg.class <= Bud::ArgExemplary
+        raise Bud::Error, "#{aggname} not declared exemplary"
       end
+
       aggpairs = [[agg, collection]]
       aa = Bud::PushArgAgg.new('argagg'+Time.new.tv_usec.to_s, toplevel.this_rule_context,
                                @collection_name, gbkey_cols, aggpairs, schema, &blk)
@@ -393,7 +389,8 @@ module Bud
   end
 
   class PushPredicate < PushStatefulElement
-    def initialize(pred_symbol, elem_name=nil, collection_name=nil, bud_instance=nil, schema_in=nil, &blk)
+    def initialize(pred_symbol, elem_name=nil, collection_name=nil,
+                   bud_instance=nil, schema_in=nil, &blk)
       @pred_symbol = pred_symbol
       @in_buf = []
       super(elem_name, bud_instance, collection_name, schema_in, &blk)
@@ -465,20 +462,21 @@ module Bud
       @collection.invalidate_at_tick # need to scan afresh if collection invalidated.
     end
 
-    # collection of others to rescan/invalidate if this scanner's collection
-    # were to be invalidated.
+    # What should be rescanned/invalidated if this scanner's collection were to
+    # be invalidated.
     def invalidate_at_tick(rescan, invalidate)
       @rescan_set = rescan
       @invalidate_set = invalidate
     end
 
     def add_rescan_invalidate(rescan, invalidate)
-      # if the collection is to be invalidated, the scanner needs to be in
+      # If the collection is to be invalidated, the scanner needs to be in
       # rescan mode
       rescan << self if invalidate.member? @collection
 
-      # in addition, default PushElement rescan/invalidate logic applies
-      super
+      # Pass the current state to each output collection and see if they end up
+      # marking this node for rescan
+      invalidate_tables(rescan, invalidate)
 
       # Note also that this node can be nominated for rescan by a target node;
       # in other words, a scanner element can be set to rescan even if the
@@ -487,12 +485,10 @@ module Bud
 
     def scan(first_iter)
       if @force_rescan
-        # Scan entire storage
         @collection.each_raw {|item| push_out(item)}
         @force_rescan = false
       elsif first_iter
         if rescan
-          # Scan entire storage
           @collection.each_raw {|item| push_out(item)}
         else
           # In the first iteration, tick_delta would be non-null IFF the

data/lib/bud/executor/join.rb

@@ -7,17 +7,19 @@ module Bud
 
     def initialize(rellist, bud_instance, preds=nil) # :nodoc: all
       @rels = rellist
-      @relnames = @rels.map{|r| r.elem_name}
+      @relnames = @rels.map{|r| r.qualified_tabname}
       @cols = []
       @bud_instance = bud_instance
       @origpreds = preds
-      @localpreds = nil
+      @localpreds = []
       @selfjoins = []
+      @keys = []
+      @key_attnos = [[], []]
       @missing_keys = Set.new
 
       # if any elements on rellist are PushSHJoins, suck up their contents
       @all_rels_below = []
-      rellist.each do |r|
+      @rels.each do |r|
         if r.class <= PushSHJoin
           @all_rels_below += r.all_rels_below
           preds += r.origpreds
@@ -25,12 +27,13 @@ module Bud
           @all_rels_below << r
         end
       end
+      @left_is_array = @all_rels_below.length > 2
 
       # check for self-joins: we currently only handle 2 instances of the same
       # table per rule
       counts = @all_rels_below.reduce({}) do |memo, r|
-        memo[r.elem_name] ||= 0
-        memo[r.elem_name] += 1
+        memo[r.qualified_tabname] ||= 0
+        memo[r.qualified_tabname] += 1
         memo
       end
       counts.each do |name, cnt|
@@ -41,13 +44,12 @@ module Bud
       # derive schema: one column for each table.
       # duplicated inputs get distinguishing numeral
       @cols = []
-      index = 0
       retval = @all_rels_below.reduce({}) do |memo, r|
-        index += 1
-        memo[r.tabname.to_s] ||= 0
-        newstr = r.tabname.to_s + ((memo[r.tabname.to_s] > 0) ? ("_" + memo[r.tabname.to_s].to_s) : "")
+        r_name = r.qualified_tabname.to_s
+        memo[r_name] ||= 0
+        newstr = r_name + (memo[r_name] > 0 ? "_#{memo[r_name]}" : "")
         @cols << newstr.to_sym
-        memo[r.tabname.to_s] += 1
+        memo[r_name] += 1
         memo
       end
 
@@ -70,7 +72,7 @@ module Bud
     private
     def setup_state
       sid = state_id
-      @tabname = ("(" + @all_rels_below.map{|r| r.tabname}.join('*') +"):"+sid.to_s).to_sym
+      @tabname = ("(" + @all_rels_below.map{|r| r.qualified_tabname}.join('*') +"):"+sid.to_s).to_sym
       @hash_tables = [{}, {}]
     end
 
@@ -80,25 +82,26 @@ module Bud
       # print "setting up preds for #{@relnames.inspect}(#{self.object_id}): "
       allpreds = disambiguate_preds(preds)
       allpreds = canonicalize_localpreds(@rels, allpreds)
-      # check for refs to collections that aren't being joined, Issue 191
+
+      # check for refs to collections that aren't being joined
       unless @rels[0].class <= Bud::PushSHJoin
-        tabnames = @rels.map{ |r| r.tabname }
         allpreds.each do |p|
-          unless tabnames.include? p[0][0]
+          unless @relnames.include? p[0][0]
             raise Bud::CompileError, "illegal predicate: collection #{p[0][0]} is not being joined"
           end
-          unless tabnames.include? p[1][0]
+          unless @relnames.include? p[1][0]
             raise Bud::CompileError, "illegal predicate: collection #{p[1][0]} is not being joined"
           end
         end
       end
+
       @localpreds = allpreds.reject do |p|
         # reject if it doesn't match the right (leaf node) of the join
         # or reject if it does match, but it can be evaluated by a lower join
-        # i.e. one that also has this table on the right (lead node)
-        p[1][0] != @rels[1].tabname \
-        or (p[0][0] != @rels[1].tabname \
-            and p[1][0] == @rels[1].tabname and @selfjoins.include? @rels[1].tabname)
+        # i.e. one that also has this table on the right (leaf node)
+        p[1][0] != @rels[1].qualified_tabname \
+        or (p[0][0] != @rels[1].qualified_tabname \
+            and p[1][0] == @rels[1].qualified_tabname and @selfjoins.include? @rels[1].qualified_tabname)
       end
 
       # only allow preds on the same table name if they're on a self-joined table
@@ -108,9 +111,9 @@ module Bud
         end
       end
 
-      @localpreds += allpreds.map do |p|
-        p if p[0][0] == p[1][0] and (p[1][0] == @rels[0].tabname or p[1][0] == @rels[1].tabname)
-      end.compact
+      @localpreds += allpreds.select do |p|
+        p[0][0] == p[1][0] and (p[1][0] == @rels[0].qualified_tabname or p[1][0] == @rels[1].qualified_tabname)
+      end
       otherpreds = allpreds - @localpreds
       unless otherpreds.empty?
         unless @rels[0].class <= Bud::PushSHJoin
@@ -119,20 +122,26 @@ module Bud
         @rels[0].setup_preds(otherpreds)
       end
 
-      if @localpreds.length > 0
-        @right_offset = @localpreds.first[1][1]
-        @left_subtuple, @left_offset = join_offset(@localpreds.first[0])
-        @keys = [[@left_subtuple, @left_offset], [1, @right_offset]]
-      else
-        @keys = []
+      @localpreds.each do |lp|
+        right_offset = lp[1][1]
+        left_subtuple, left_offset = join_offset(lp[0])
+        @keys << [[left_subtuple, left_offset], [1, right_offset]]
       end
+
+      # Optimize for a common case. When we're just fetching key values from
+      # an input tuple, lookup the column offsets we need to fetch for each
+      # input. This doesn't apply when we're computing the key for the left
+      # input and @left_is_array is true.
+      @key_attnos = []
+      @key_attnos[0] = @keys.map {|k| k[0][1]}
+      @key_attnos[1] = @keys.map {|k| k[1][1]}
     end
 
     public
     def invalidate_cache
       @rels.each_with_index do |source_elem, i|
         if source_elem.rescan
-          puts "#{tabname} rel:#{i}(#{source_elem.tabname}) invalidated" if $BUD_DEBUG
+          puts "#{qualified_tabname} rel:#{i}(#{source_elem.qualified_tabname}) invalidated" if $BUD_DEBUG
           @hash_tables[i] = {}
           if i == 0
             # Only if i == 0 because outer joins in Bloom are left outer joins.
@@ -156,7 +165,7 @@ module Bud
       # referenced in entry.
       subtuple = 0
       all_rels_below[0..all_rels_below.length-1].each_with_index do |t,i|
-        if t.tabname == entry[0]
+        if t.qualified_tabname == entry[0]
           subtuple = i
           break
         end
@@ -197,20 +206,23 @@ module Bud
       dorels = (rel.nil? ? @all_rels_below : [rel])
       match = nil
       dorels.each do |r|
-        match ||= r if bud_instance.tables[r.elem_name].respond_to?(aname)
-        if bud_instance.tables[r.elem_name].respond_to?(aname) and match != r
-          raise Bud::CompileError, "ambiguous attribute :#{aname} in both #{match.tabname} and #{r.tabname}"
+        r_name = r.qualified_tabname
+        tbl = bud_instance.toplevel.tables[r_name]
+        match ||= r if tbl.respond_to?(aname)
+        if tbl.respond_to?(aname) and match != r
+          raise Bud::CompileError, "ambiguous attribute :#{aname} in both #{match.qualified_tabname} and #{r_name}"
         end
       end
       if match.nil?
-        raise Bud::CompileError, "attribute :#{aname} not found in any of #{dorels.map{|t| t.tabname}.inspect}"
+        rel_names = dorels.map{|t| t.qualified_tabname.to_s}.to_s
+        raise Bud::CompileError, "attribute :#{aname} not found in any of #{rel_names}"
       end
-      bud_instance.tables[match.elem_name].send(aname)
+      match.send(aname)
     end
 
+    # decompose each pred into a binary pred
     protected
     def decomp_preds(*preds) # :nodoc:all
-                             # decompose each pred into a binary pred
       return nil if preds.empty? or preds == [nil]
       newpreds = []
       preds.each do |p|
@@ -225,38 +237,8 @@ module Bud
     def canonicalize_localpreds(rel_list, preds) # :nodoc:all
       retval = preds.map do |p|
         # reverse if lhs is rel_list[1], *unless* it's a self-join!
-        (p[0][0] == rel_list[1].tabname and p[0][0] != p[1][0]) ? p.reverse : p
-      end
-    end
-
-    private
-    # right is a tuple
-    # left is a tuple or an array (combo) of joined tuples.
-    def test_locals(left, left_is_array, right, *skips)
-      retval = true
-      if (skips and @localpreds.length > skips.length)
-        # check remainder of the predicates
-        @localpreds.each do |pred|
-          # skip skips
-          next if (skips.include? pred)
-          # assumption of left-deep joins here
-          if pred[1][0] != @rels[1].tabname
-            raise Bud::Error, "expected rhs table to be #{@rels[1].tabname}, not #{pred[1][0]}"
-          end
-          rfield = right[pred[1][1]]
-          if left_is_array
-            ix, off = join_offset(pred[0])
-            lfield = left[ix][off]
-          else
-            lfield = left[pred[0][1]]
-          end
-          if lfield != rfield
-            retval = false
-            break
-          end
-        end
+        (p[0][0] == rel_list[1].qualified_tabname and p[0][0] != p[1][0]) ? p.reverse : p
       end
-      return retval
     end
 
     undef do_insert
@@ -269,11 +251,11 @@ module Bud
       # again if we didn't rescan now.
       replay_join if @rescan
 
-      if @selfjoins.include? source.elem_name
+      if @selfjoins.include? source.qualified_tabname
         offsets = []
-        @relnames.each_with_index{|r,i| offsets << i if r == source.elem_name}
+        @relnames.each_with_index{|r,i| offsets << i if r == source.qualified_tabname}
       else
-        offsets = [@relnames.index(source.elem_name)]
+        offsets = [@relnames.index(source.qualified_tabname)]
       end
       raise Bud::Error, "item #{item.inspect} inserted into join from unknown source #{source.elem_name}" if offsets == $EMPTY
       offsets.each do |offset|
@@ -283,16 +265,16 @@ module Bud
 
     protected
     def insert_item(item, offset)
-      if @keys.nil? or @keys.empty?
-        the_key = nil
-      else
-        # assumes left-deep trees
-        if all_rels_below.length > 2 and offset == 0
-          the_key = item[@keys[0][0]][@keys[0][1]]
-        else
-          the_key = item[@keys[offset][1]]
+      # assumes left-deep trees
+      if @left_is_array and offset == 0
+        the_key = @keys.map do |k|
+          left_subtuple, left_offset = k.first
+          item[left_subtuple][left_offset]
         end
+      else
+        the_key = item.values_at(*@key_attnos[offset])
       end
+
       #build
       # puts "building #{item.inspect} into @source[#{offset}] on key #{the_key.inspect}"
       if (@hash_tables[offset][the_key] ||= Set.new).add? item
@@ -340,11 +322,10 @@ module Bud
           left = m
           right = item
         end
-        left_is_array = all_rels_below.length > 2
-        if @localpreds.nil? or @localpreds.length == 1 or test_locals(left, left_is_array, right, @localpreds.first)
-          result = left_is_array ? left + [right] : [left, right] # FIX: reduce arrays being created.
-          push_out(result)
-        end
+
+        # FIX: reduce arrays being created
+        result = @left_is_array ? left + [right] : [left, right]
+        push_out(result)
       end
     end
 
@@ -372,13 +353,16 @@ module Bud
     # matches in the 2nd, nil-pad it and include it in the output.
     public
     def outer(*preds, &blk)
+      if @all_rels_below.length > 2
+        raise Bud::Error, "outer joins cannot be used with more than 2 join relations"
+      end
       pairs(*preds, &blk)
       self.extend(Bud::PushSHOuterJoin)
     end
 
     public
     def rights(*preds, &blk)
-      @cols = blk.nil? ? @bud_instance.tables[@rels[1].tabname].cols : nil
+      @cols = blk.nil? ? @bud_instance.toplevel.tables[@rels[1].qualified_tabname].cols : nil
       setup_accessors if blk.nil?
       pairs(*preds) do |x,y|
         blk.nil? ? y : blk.call(y)
@@ -387,7 +371,7 @@ module Bud
 
     public
     def lefts(*preds, &blk)
-      @cols = blk.nil? ? @bud_instance.tables[@rels[0].tabname].cols : nil
+      @cols = blk.nil? ? @bud_instance.toplevel.tables[@rels[0].qualified_tabname].cols : nil
       setup_accessors if blk.nil?
       pairs(*preds) do |x,y|
         blk.nil? ? x : blk.call(x)
@@ -457,17 +441,11 @@ module Bud
   end
 
   module PushSHOuterJoin
+    # XXX: duplicates code from PushSHJoin
     private
     def insert_item(item, offset)
-      if @keys.nil? or @keys.empty?
-        the_key = nil
-      else
-        if all_rels_below.length > 2 and offset == 1
-          the_key = item[@keys[1][0]][@keys[1][1]]
-        else
-          the_key = item[@keys[offset][1]]
-        end
-      end
+      the_key = item.values_at(*@key_attnos[offset])
+
       #build
       # puts "building #{item.inspect} into @source[#{offset}] on key #{the_key.inspect}"
       if (@hash_tables[offset][the_key] ||= Set.new).add? item
@@ -478,7 +456,8 @@ module Bud
         if the_matches.nil? and offset == 0 # only doing Left Outer Join right now
           @missing_keys << the_key
         else
-          @missing_keys.delete(the_key) # no longer missing no matter which side this tuple is
+          # no longer missing no matter which side this tuple is
+          @missing_keys.delete(the_key)
           process_matches(item, the_matches, offset) unless the_matches.nil?
         end
       end
@@ -497,9 +476,11 @@ module Bud
 
     private
     def push_missing
+      left_hash = @hash_tables[0]
+      null_tuple = @rels[1].null_tuple
       @missing_keys.each do |key|
-        @hash_tables[0][key].each do |t|
-          push_out([t, @rels[1].null_tuple])
+        left_hash[key].each do |t|
+          push_out([t, null_tuple])
         end
       end
     end
@@ -520,8 +501,8 @@ module Bud
       @lhs, @rhs = rellist
       @lhs_keycols = nil
       @rhs_keycols = nil
-      name_in = "#{@lhs.tabname}_notin_#{@rhs.tabname}"
-      super(name_in, bud_instance)
+      name_in = "#{@lhs.qualified_tabname}_notin_#{@rhs.qualified_tabname}"
+      super(name_in, bud_instance, nil, @lhs.schema)
       setup_preds(preds) unless preds.empty?
       @rhs_rcvd = false
       @hash_tables = [{},{}]
@@ -553,7 +534,7 @@ module Bud
     def find_col(colspec, rel)
       if colspec.is_a? Symbol
         unless rel.respond_to? colspec
-          raise Bud::Error, "attribute :#{colspec} not found in #{rel.tabname}"
+          raise Bud::Error, "attribute :#{colspec} not found in #{rel.qualified_tabname}"
         end
         col_desc = rel.send(colspec)
       elsif colspec.is_a? Array
@@ -561,7 +542,7 @@ module Bud
       else
         raise Bud::Error, "symbol or column spec expected. Got #{colspec}"
       end
-      col_desc[1] # col_desc is of the form [tabname, colnum, colname]
+      col_desc[1] # col_desc is of the form [tabname, colnum, colname, seqno]
     end
 
     def get_key(item, offset)
@@ -588,7 +569,8 @@ module Bud
       key = get_key(item, offset)
       (@hash_tables[offset][key] ||= Set.new).add item
       if @rhs_rcvd and offset == 0
-        push_lhs(key, item)
+        rhs_values = @hash_tables[1][key]
+        process_match(item, rhs_values)
       end
     end
 
@@ -599,16 +581,12 @@ module Bud
       unless @rhs_rcvd
         @rhs_rcvd = true
         @hash_tables[0].each do |key,values|
-          values.each {|item| push_lhs(key, item)}
+          rhs_values = @hash_tables[1][key]
+          values.each {|item| process_match(item, rhs_values)}
         end
       end
     end
 
-    def push_lhs(key, lhs_item)
-      rhs_values = @hash_tables[1][key]
-      process_match(lhs_item, rhs_values)
-    end
-
     def process_match(lhs_item, rhs_values)
       if rhs_values.nil?
         # no corresponding rhs. Include in output
@@ -628,11 +606,11 @@ module Bud
       raise Bud::Error if @rhs_rcvd     # sanity check; should already be reset
 
       if @lhs.rescan
-        puts "#{tabname} rel:#{@lhs.tabname} invalidated" if $BUD_DEBUG
+        puts "#{tabname} rel:#{@lhs.qualified_tabname} invalidated" if $BUD_DEBUG
         @hash_tables[0] = {}
       end
       if @rhs.rescan
-        puts "#{tabname} rel:#{@rhs.tabname} invalidated" if $BUD_DEBUG
+        puts "#{tabname} rel:#{@rhs.qualified_tabname} invalidated" if $BUD_DEBUG
         @hash_tables[1] = {}
       end
     end

data/lib/bud/lattice-core.rb

@@ -112,8 +112,6 @@ class Bud::Lattice
   end
 end
 
-# TODO:
-# * merge logic for set-oriented collections
 class Bud::LatticePushElement
   attr_reader :wired_by, :outputs
   attr_accessor :invalidated, :rescan
@@ -123,6 +121,7 @@ class Bud::LatticePushElement
     @wired_by = []
     @outputs = []
     @pendings = []
+    @deletes = []
     @invalidated = true
     @rescan = true
   end
@@ -133,6 +132,8 @@ class Bud::LatticePushElement
       @outputs << element
     when :pending
       @pendings << element
+    when :delete
+      @deletes << element
     else
       raise Bud::Error, "unrecognized wiring kind: #{kind}"
     end
@@ -141,7 +142,7 @@ class Bud::LatticePushElement
   end
 
   def check_wiring
-    if @outputs.empty? and @pendings.empty?
+    if @outputs.empty? and @pendings.empty? and @deletes.empty?
       raise Bud::Error, "no output specified for #{inspect}"
     end
   end
@@ -149,12 +150,15 @@ class Bud::LatticePushElement
   def print_wiring(depth=0, accum="")
     puts "#{'  ' * depth}#{accum} #{inspect}"
 
-    [@outputs, @pendings].each do |buf|
-      if buf == @outputs
-        next_accum = "=> "
-      else
-        next_accum = "+> "
-      end
+    [@outputs, @pendings, @deletes].each do |buf|
+      next_accum = case buf
+                   when @outputs
+                     "=> "
+                   when @pendings
+                     "+> "
+                   when @deletes
+                     "-> "
+                   end
 
       buf.each do |o|
         if o.respond_to? :print_wiring
@@ -171,7 +175,7 @@ class Bud::LatticePushElement
   end
 
   def wirings
-    @outputs + @pendings
+    @outputs + @pendings + @deletes
   end
 
   def method_missing(meth, *args, &blk)
@@ -193,9 +197,9 @@ class Bud::LatticePushElement
       # operators (e.g., <=, <+) take a collection of tuples, so we need to
       # convert the lattice value into a collection of tuple-like values. For
       # now, we hardcode a single way to do this: we simply assume the value
-      # embedded inside the lattice is Enumerable. We also allow lattice
-      # morphisms to just produce Enumerable values directly, so we don't call
-      # reveal in that case.
+      # embedded inside the lattice is an Enumerable that contains tuple-like
+      # values. We also allow lattice morphisms to just produce Enumerable
+      # values directly, so we don't call reveal in that case.
       # XXX: rethink this.
       if o.class <= Bud::BudCollection
         o <= (v.class <= Bud::Lattice ? v.reveal : v)
@@ -210,6 +214,10 @@ class Bud::LatticePushElement
         o <+ v
       end
     end
+    @deletes.each do |o|
+      raise Bud::Error unless o.class <= Bud::BudCollection
+      o.pending_delete(v.class <= Bud::Lattice ? v.reveal : v)
+    end
   end
 
   def flush