You’ve done more with this now than I have :), thanks for taking the time to look at this so closely and then share your findings with everyone.

The if-then-else construct is faster than case.

Taking advantage of the fact that finding the intersection of list pairs is faster on lists of raw integers than on lists of ‘wrapped’ integers, I tried doing the intersect on raw lists that exactly mirror the target wrapped lists. I store the index of the matching integers in the raw list intersect result. I then use that result to pull out the corresponding wrapped integers from wrapped list1. In ‘wraps w/ prebuilt’ raws I used the raws lists that were already created for testing raw list intersection methods. In ‘wraps build raws’ I build the raw lists from scratch within the method.

The latter optimization could, of course, be applied to your methods.

ENUMERATOR BASED INTERSECT: CASE vs IF-THEN-ELSE
---------------------------------------------------------
list1 size: 1064  list2 size: 4014
intersect list size: 416
benchmark repeats: 1000
             user     system      total        real
case:   17.140000   0.000000  17.140000 ( 17.171875)
if:     14.438000   0.000000  14.438000 ( 14.484375)
ENUMERATOR BASED INTERSECT: RAW LISTS AS PROXIES
---------------------------------------------------------
list1 size: 1064  list2 size: 4014
intersect list size: 416
benchmark repeats: 1000
                              user     system      total        real
raws only:               15.375000   0.031000  15.406000 ( 15.406250)
wraps only:              49.250000   0.031000  49.281000 ( 49.390625)
wraps w/ prebuilt raws:  17.328000   0.000000  17.328000 ( 17.359375)
wraps build raws:        28.515000   0.016000  28.531000 ( 28.593750)

I cleaned up the code a bit:

  def isect_raw_indexed(list1,list2)
    result = []
    e1, e2 = list1.each_with_index, list2.each_with_index
    a, b = e1.next, e2.next
    while true
      if    a[0] < = > b[0] then b = e2.next
      else result << a[1] ;a = e1.next; b = e2.next
      end
    end
    rescue StopIteration; return result
  end
  def isect_wrapped(list1,list2)
    result = []
    e1, e2 = list1.each, list2.each
    a, b = e1.next, b = e2.next
    while true
      if    a.value < = > b.value then b = e2.next
      else result << a.value ;a = e1.next; b = e2.next
      end
    end
    rescue StopIteration; return result
  end
  def isect_wrapped_with_indexed_raws(raws1, raws2, list1)
    isects = isect_raw_indexed(raws1, raws2)
    isects.inject([]) {|acc,item| acc << list1[item]}
  end
  def isect_wrapped_with_indexed_raws2(list1,list2)
    r1 = list1.map {|i| i.value}
    r2 = list2.map {|i| i.value}
    isects = isect_raw_indexed(r1, r2)
    isects.inject([]) {|acc,item| acc << list1[item]}
  end

def sorted_list_intersection(list1,list2)
  	result = []
  	e1, e2 = list1.each,  list2.each
  	a, b = e1.next,  e2.next
  	while true
  	  begin
  		case a < = > b
  		  when -1 then a = e1.next
  		  when +1 then b = e2.next
  		  else result << a; a = e1.next; b = e2.next
  		end
  	  rescue StopIteration;  return result
  	  end
  	end
  end

The method also depends on an appropriate definition of the ‘space-ship operator’. “”

The begin..end pair are not needed in a method definition. The while is just to setup an infinite loop that is exited when an error (StopIteration ) is raised. So I can clean the example up a bit:

  def sorted_set_intersection(seta,setb)
  	result = []
  	ea = seta.each
  	eb = setb.each
  	a = ea.first
  	b = eb.first
  	loop do
  	  case a < = > b
  		when -1: a = ea.next
  		when +1: b = eb.next
  		else result << a
  	  end
  	end
  rescue StopIteration
  	result
  end

Enumerators raise the StopIteration error when they move beyond the end of the enumerable by single stepping through.

The method also depends on an appropriate definition of < = >

def intersection(seta,setb)
ea = seta.each; a = ea.first
eb = setb.each; b= eb.first
result = []
begin
while true
case a b
when -1: a = ea.next
when +1: b = eb.next
else result << a
end
end
rescue
result
end
end

this of course assumes seta and setb are ordered