diff --git a/examples/random_scripts.rb b/examples/random_scripts.rb
new file mode 100644
index 0000000..32d6515
--- /dev/null
+++ b/examples/random_scripts.rb
@@ -0,0 +1,75 @@
+#encoding: utf-8
+require_relative '../lib/duck'
+require 'timeout'
+include Duck
+
+############
+# A simple experiment in the diversity of Duck scripts.
+#
+# We generate Duck scripts from random tokens, run them with different inputs 'x'
+#   to observe how many act differently with just the change in inputs value.
+
+
+######
+# some conveniences, first:
+
+ARITHMETIC_TOKENS = ["+","-","*","/","inc","dec","if"] + ['k','f','x'] * 5
+ALL_MESSAGES =
+  [Assembler,Binder,Bool,Closure,Collector,
+  Decimal,Error,Int,Interpreter,Item,Iterator,List,Local,
+  Message,Number,Pipe,Proxy,Script,Span,Variable].inject([]) {|messages,klass| (messages | klass.recognized_messages)}
+  
+@everything = 
+  ALL_MESSAGES + ['m','k','b','f','x'] * 10
+
+def random_tokens(how_many,source_list)
+  tokens = how_many.times.collect do
+    t = source_list.sample
+    case
+    when t=="k" # some random integer
+      val = "#{(0..9).to_a.sample}"
+      rand < 0.5 ? val : "-#{val}"
+    when t=="m" # some random local message
+      "_#{('a'..'z').to_a.sample}"
+    when t=="b" # some random boolean
+      rand < 0.5 ? "T" : "F"
+    when t=="f" # some random float
+      val = "#{(0..9).to_a.sample}.#{(0..9).to_a.sample}"
+      rand < 0.5 ? val : "-#{val}"
+    else # just what it says
+      t.to_s
+    end
+  end
+end
+
+
+def random_script(how_many, source_list=@everything)
+  parts = random_tokens(how_many, source_list)
+  parts.join(" ")
+end
+
+############
+#
+# We generate 500 random 50-token scripts
+# set variable :x1 and :x2
+# run each script, and count the number of ticks execution takes,
+# and report the top two Number values present on the interpreter when it's done
+
+
+puts "trial, ticks(x1), ticks(x2), y1(x1), y1(x2), y2(x1), y2(x2)"
+(0..500).each do |i|
+  pts = 100
+  x1 = 16
+  x2 = 19
+  script = random_script(pts)
+  begin
+    Timeout::timeout(120) do
+      random_one = interpreter(script:script, binder:{x:int(x1)}).run
+      random_two = interpreter(script:script, binder:{x:int(x2)}).run
+      puts"#{i}: #{random_one.ticks}, #{random_two.ticks}, #{random_one.emit!(Number)||'nil'}, #{random_two.emit!(Number)||'nil'}, #{random_one.emit!(Number)||'nil'}, #{random_two.emit!(Number)||'nil'}"
+    end
+  rescue Exception => e
+    puts "ERROR:#{e.message} -- #{e.backtrace} #{script.inspect}"
+    raise
+  end
+end
\ No newline at end of file
diff --git a/examples/trivial_gp.rb b/examples/trivial_gp.rb
index 6aa25d5..527f2d3 100644
--- a/examples/trivial_gp.rb
+++ b/examples/trivial_gp.rb
@@ -117,8 +117,8 @@ def evaluate(x_y_pairs_hash={},out_file = nil)
 NUMBERLESS_TOKENS = ["+","-","*","/","inc","dec"]+['x']*4  # EXERCISE (one hand tied)
 ALL_MESSAGES =
   [Assembler,Binder,Bool,Closure,Collector,
-  Decimal,Error,Int,Interpreter,Item,List,
-  Message,Number,Pipe,Script,Variable].inject([]) {|messages,klass| (messages | klass.recognized_messages)}
+  Decimal,Error,Int,Interpreter,Item,Iterator,List,Local,
+  Message,Number,Pipe,Proxy,Script,Span,Variable].inject([]) {|messages,klass| (messages | klass.recognized_messages)}
 
 @experiment_tokens = ALL_MESSAGES + SIMPLE_TOKENS
 
@@ -140,10 +140,10 @@ def random_tokens(how_many,source_list)
 end
 
 
-pop_size = 100
+pop_size = 50
 updates = pop_size*3
 cycles = 500
-standard_length = 100
+standard_length = 40
 population = pop_size.times.collect {Answer.new(random_tokens(standard_length,@experiment_tokens))}
 
 File.open("./data/scores.csv", "w") do |tracefile|
@@ -180,7 +180,7 @@ def random_tokens(how_many,source_list)
       mom, dad = population[mom_index], population[dad_index]
       
       # EXERCISE (recombination)
-      crossover1,crossover2 = mom.crossover_result(dad, false)
+      crossover1,crossover2 = mom.crossover_result(dad)
       baby1 = Answer.new(crossover1).mutant(3,@experiment_tokens) # EXERCISE (ontological creep)
       baby2 = Answer.new(crossover2).mutant(3,@experiment_tokens)
       
diff --git a/lib/assembler_class.rb b/lib/assembler_class.rb
index 9cd85b4..a6442e5 100644
--- a/lib/assembler_class.rb
+++ b/lib/assembler_class.rb
@@ -85,9 +85,7 @@ def count_a_tick
     
     
     def give_ticks
-      recorded_ticks = @ticks
-      @ticks = 0
-      return recorded_ticks
+      return @ticks
     end
     
     
diff --git a/lib/binder_class.rb b/lib/binder_class.rb
index 4cb8195..5bee152 100644
--- a/lib/binder_class.rb
+++ b/lib/binder_class.rb
@@ -2,13 +2,20 @@
 module Duck
   class Binder < List
     attr_accessor :contents
-  
+    
+    
     def initialize(contents=[])
       @contents = contents
       @needs = []
     end
     
     
+    def deep_copy
+      Binder.new( @contents.collect {|item| item.deep_copy})
+    end
+    
+    
+    
     def recognize_message?(string)
       mine_and_theirs = contents_recognize_message?(string) || Binder.recognized_messages.include?(string.intern)
     end
@@ -38,7 +45,7 @@ def index_of_next_respondent_to(msg)
     def produce_respondent(msg)
       which = index_of_next_respondent_to(msg.intern)
       if which.nil?
-        result = personally_recognizes?(msg) ? self : nil
+        result = personally_recognizes?(msg) ? self.deep_copy : nil
       else
         if @contents[which].kind_of?(Binder)
           result = @contents[which].produce_respondent(msg)
diff --git a/lib/bool_class.rb b/lib/bool_class.rb
index c64130a..fc52861 100644
--- a/lib/bool_class.rb
+++ b/lib/bool_class.rb
@@ -54,5 +54,10 @@ def to_s
     duck_handle :to_int do
       Int.new(@value ? 1 : 0)
     end
+    
+    
+    duck_handle :to_script do
+      Script.new(@value ? 'T' : 'F')
+    end
   end
 end
\ No newline at end of file
diff --git a/lib/decimal_class.rb b/lib/decimal_class.rb
index 5ae0d02..c061ade 100644
--- a/lib/decimal_class.rb
+++ b/lib/decimal_class.rb
@@ -1,10 +1,9 @@
 #encoding: utf-8
-
-def decimal(value)
-  Decimal.new(value)
-end
-
 module Duck
+  def decimal(value)
+    Decimal.new(value)
+  end
+
   class Decimal < Number
     def to_s
       "#{@value}"
@@ -38,6 +37,19 @@ def to_s
     end
     
     
+    duck_handle :count do
+      Iterator.new(start:0.0, end:@value, inc:1.0,:response => :index).run
+    end
+    
+    
+    duck_handle :count_by do
+      Closure.new(["neg"], "#{self.inspect}.count_by(?)") do |number|
+        Iterator.new(start:0.0, end:@value, inc:number.value.to_f, :response => :index).run
+      end
+    end
+    
+    
+    
     duck_handle :rand do
       case 
       when @value > 0.0
diff --git a/lib/int_class.rb b/lib/int_class.rb
index 56eef24..9338fb9 100644
--- a/lib/int_class.rb
+++ b/lib/int_class.rb
@@ -1,11 +1,10 @@
 #encoding: utf-8
-
-def int(value)
-  Int.new(value)
-end
-
-
 module Duck
+  
+  def int(value)
+    Int.new(value)
+  end
+  
   class Int < Number
     def type_cast_result(arg, operator)
       arg.class == Decimal ?
@@ -58,12 +57,24 @@ def to_s
       i = self.value
       Closure.new(["be"],"#{i} of ?") do |item|
         item.to_s.length * i <= @@result_size_limit ?
-        i.times.collect {|i| item.clone} :
+        i.times.collect {|i| item.deep_copy} :
         Error.new("OVERSIZED RESULT")
       end
     end
-  
-  
+    
+    
+    duck_handle :count do
+      Iterator.new(start:0, end:@value, inc:1,:response => :index).run
+    end
+    
+    
+    duck_handle :count_by do
+      Closure.new(["inc"],"#{self.inspect}.count_by(?)") do |increment|
+        Iterator.new(start:0, end:@value, inc:increment.value, :response => :index).run
+      end
+    end
+    
+    
     duck_handle :dec do
       Int.new @value - 1
     end
@@ -89,7 +100,7 @@ def to_s
     duck_handle :times_do do
       Closure.new(["be"], "#{self.inspect}.times_do(?)") do |item|
         @value > 0 ?
-          [Iterator.new(start:0, end:@value, contents:[item]), Message.new("run")] :
+          Iterator.new(start:0, end:@value, contents:[item]).run :
           self
       end
     end
diff --git a/lib/interpreter_class.rb b/lib/interpreter_class.rb
index 34febce..7bbb92c 100644
--- a/lib/interpreter_class.rb
+++ b/lib/interpreter_class.rb
@@ -193,12 +193,7 @@ def trace_used_as_arg(position)
     def trace_uses_arg(position)
       write_to_trace "   ... grabbed the #{@contents[position].class} #{@contents[position].inspect}" unless position.nil?
     end
-    
-    
-    def trace_entire_buffer
-      write_to_trace "   ... the buffer is now #{@buffer.inspect}"
-    end
-    
+        
     
     
     def trace_pushed_item(item)
@@ -215,7 +210,6 @@ def process_next_buffer_item
       unless buffer.empty?
         count_a_tick
         @staged_item = @buffer.delete_at(0)
-        trace_entire_buffer if @trace
         trace_staging if @trace
         next_arg_position = next_contents_index_wanted_by(@staged_item)
         if next_arg_position.nil? 
diff --git a/lib/iterator_class.rb b/lib/iterator_class.rb
index a7236fd..b97d109 100644
--- a/lib/iterator_class.rb
+++ b/lib/iterator_class.rb
@@ -8,6 +8,7 @@ class Iterator < List
     attr_accessor :index
     attr_accessor :contents
     attr_accessor :min_value, :max_value
+    attr_accessor :response
     
     def initialize(args = {})
       default_args = {start:0, end:0, inc:1, index:nil}
@@ -23,6 +24,7 @@ def initialize(args = {})
         end 
       @index = args[:index] || @start
       @contents = args[:contents] || []
+      @response = args[:response] || :contents
       @min_value,@max_value = [@start,@end].minmax
       @needs = []
     end
@@ -34,21 +36,25 @@ def deep_copy
         end:@end,
         inc:@inc,
         index:@index,
-        contents:@contents.collect {|item| item.deep_copy}
+        contents:@contents.collect {|item| item.deep_copy},
+        response:@response,
       )
     end
     
     
     def to_s
-      "(#{@start}..#{@index}..#{@end})=>#{@contents.inspect}"
+      rounded_index = @index.kind_of?(Float) ? "~(#{@index.round(3)})" : "#{@index}"
+      return "(#{@start}..#{rounded_index}..#{@end})=>#{@contents}"
     end
     
+    
     def index_in_range?
       @start < @end ?
       @min_value <= @index && @index < @max_value :
       @min_value < @index && @index <= @max_value 
     end
     
+    
     def reset_index_within_range
       if !index_in_range?
         @index = @min_value if @index < @min_value
@@ -56,14 +62,48 @@ def reset_index_within_range
       end
     end
     
+    
+    def output_value
+      case @response
+      when :element
+        output =  @contents.empty? ? [] : [@contents[@index % @contents.length].deep_copy]
+      when :index
+        output = @index.kind_of?(Float) ? [Decimal.new(@index)] : [Int.new(@index)]
+      else
+        output = @contents.collect {|item| item.deep_copy}
+      end
+      return output
+    end
+    
+    
     # DUCK HANDLERS
     
     
     duck_handle :∪ do
       Closure.new(["shatter"], "#{self.inspect} ∪ ?") do |listy_thing|
-        aggregated = listy_thing.contents + @contents
+        result_iterator = self.deep_copy
+        aggregated = listy_thing.contents + result_iterator.contents
         unionized = aggregated.uniq {|element| element.inspect}
-        @contents = unionized
+        result_iterator.contents = unionized
+        result_iterator
+      end
+    end
+    
+    
+    duck_handle :again do
+      if index_in_range?
+        output_array = self.output_value
+        output_array.unshift(self)
+      else
+        reset_index_within_range
+        self
+      end
+    end
+    
+    
+    duck_handle :index= do
+      Closure.new(["neg"], "#{self.inspect}.index=?") do |int|
+        @index = int.value
         self
       end
     end
@@ -119,9 +159,9 @@ def reset_index_within_range
     
     duck_handle :step do
       if index_in_range?
-        output = @contents.collect {|item| item.deep_copy}
+        output_array = self.output_value
         @index += @actual_inc
-        output.unshift(self)
+        output_array.unshift(self)
       else
         reset_index_within_range
         self
diff --git a/lib/list_class.rb b/lib/list_class.rb
index bc361ae..f05a48f 100644
--- a/lib/list_class.rb
+++ b/lib/list_class.rb
@@ -1,10 +1,10 @@
 #encoding:utf-8
-
-def list(contents=[])
-  List.new(contents)
-end
-
 module Duck
+  def list(contents=[])
+    List.new(contents)
+  end
+  
+  
   class List < Item
     attr_accessor :contents
   
@@ -19,8 +19,12 @@ def deep_copy
     end
     
     
-    def emit!(msg)
-      reply = @contents.rindex {|item| item.recognize_message?(msg.intern)}
+    def emit!(key)
+      if key.class == String
+        reply = @contents.rindex {|item| item.recognize_message?(key.intern)}
+      elsif key.class == Class
+        reply = @contents.rindex {|item| item.kind_of?(key)}
+      end
       item = @contents.delete_at(reply) unless reply.nil?
       item
     end
@@ -87,8 +91,13 @@ def to_s
       @contents << @contents[-1].deep_copy unless @contents.empty?
       self
     end
-  
-  
+    
+    
+    duck_handle :each do
+      Iterator.new(start:0, end:@contents.length, :response => :element, contents:@contents).run
+    end
+    
+    
     duck_handle :empty do
       @contents = []
       self
@@ -119,13 +128,15 @@ def to_s
     end
     
     
-    duck_handle :fold_up do
-      @contents.inject do |memo, item|
+    duck_handle :fold_down do
+      @contents.reverse.inject do |memo, item|
         case
           when memo.nil?
             item
           when memo.kind_of?(Array)
-            memo.collect {|branch| branch.grab(item)}.flatten.compact
+            memo.collect do |branch|
+              branch.nil? ? item : branch.grab(item)
+            end.flatten.compact
           else
             memo.grab(item)
           end
@@ -133,13 +144,15 @@ def to_s
     end
     
     
-    duck_handle :fold_down do
-      @contents.reverse.inject do |memo, item|
+    duck_handle :fold_up do
+      @contents.inject do |memo, item|
         case
           when memo.nil?
             item
           when memo.kind_of?(Array)
-            memo.collect {|branch| branch.grab(item)}.flatten.compact
+            memo.collect do |branch|
+              branch.nil? ? item : branch.grab(item)
+            end.flatten.compact
           else
             memo.grab(item)
           end
diff --git a/lib/local_class.rb b/lib/local_class.rb
index e996a06..ac2fa1b 100644
--- a/lib/local_class.rb
+++ b/lib/local_class.rb
@@ -1,11 +1,13 @@
 module Duck
   
-  def local(string)
-    Local.new(string)
-  end
 
   class Local < Message
     
+    def local(string)
+      Local.new(string)
+    end
+    
+    
     def initialize(string)
       raise ArgumentError, "Local cannot be made from \"#{string}\" without leading underscore" unless
         string[0] == "_"
@@ -32,5 +34,11 @@ def to_s
         end
       end
     end
+    
+    
+    duck_handle :rand do
+      rand_chars = (@value.length-1).times.inject("") {|m,i| m+('a'..'z').to_a.sample}
+      Local.new("_#{rand_chars}")
+    end
   end
 end
\ No newline at end of file
diff --git a/lib/number_class.rb b/lib/number_class.rb
index a88310b..d1f06e8 100644
--- a/lib/number_class.rb
+++ b/lib/number_class.rb
@@ -4,30 +4,35 @@ class Number < Item
     duck_handle :< do
       Closure.new(["neg"],"? < #{self.value}") {|arg1| Bool.new(arg1.value < self.value)}
     end
-  
-  
+    
+    
     duck_handle :≤ do
       Closure.new(["neg"],"? ≤ #{self.value}") {|arg1| Bool.new(arg1.value <= self.value)}
     end
-  
-  
+    
+    
     duck_handle :≥ do
       Closure.new(["neg"],"? ≥ #{self.value}") {|arg1| Bool.new(arg1.value >= self.value)}
     end
-  
-  
+    
+    
     duck_handle :> do
       Closure.new(["neg"],"? > #{self.value}") {|arg1| Bool.new(arg1.value > self.value)}
     end
-  
-  
+    
+    
     duck_handle :eql do
       Closure.new(["neg"],"? == #{self.value}") {|arg1| Bool.new(arg1.value == self.value)}
     end
-  
-  
+    
+    
     duck_handle :neg do
       self.class.new(-@value)
     end
+    
+    
+    duck_handle :to_script do
+      Script.new(@value.to_s)
+    end
   end
 end
diff --git a/lib/pipe_class.rb b/lib/pipe_class.rb
index 83c3d82..36886a0 100644
--- a/lib/pipe_class.rb
+++ b/lib/pipe_class.rb
@@ -15,7 +15,7 @@ def deep_copy
       Pipe.new(new_contents)
     end
   
-    define_method( "(".intern ) {List.new(@contents.clone)}
+    define_method( "(".intern ) {List.new(@contents)}
   
     def to_s
       "λ( " + (@contents.inject("(") {|s,i| s+i.to_s+", "}).chomp(", ") + ", ?) )"
diff --git a/lib/proxy_class.rb b/lib/proxy_class.rb
index b52dbb2..d9e46fb 100644
--- a/lib/proxy_class.rb
+++ b/lib/proxy_class.rb
@@ -28,6 +28,14 @@ def to_s
     end
     
     
+    duck_handle "^greedy=".intern do
+      Closure.new(["¬"], "<INTERPRETER>.greedy=(?)") do |bool|
+        @value.greedy_flag = bool.value
+        nil
+      end
+    end
+    
+    
     duck_handle "^length".intern do
       @value.length
     end
@@ -36,7 +44,10 @@ def to_s
     duck_handle "^quote".intern do
       Closure.new(["inc"], "<SCRIPT>.quote(?)") do |int|
         how_many = int.value
-        new_string = how_many.times.inject("") {|memo,word| memo + " #{@value.script.next_word}"}
+        new_string = how_many.times.inject("") do |memo,word|
+          break memo if @value.script.value.strip.empty?
+          memo + " #{@value.script.next_word}"
+        end
         Script.new(new_string.strip)
       end
     end
@@ -45,7 +56,7 @@ def to_s
     duck_handle "^rescript".intern do
       Closure.new(["lowercase"], "<SCRIPT>.prepend(?)") do |other_script|
         old_script = @value.script.value
-        if other_script.length + old_script.length < 32000
+        if other_script.length + old_script.length < 20000
           @value.script = Script.new(other_script.value + " " + old_script)
           nil
         else
@@ -58,5 +69,11 @@ def to_s
     duck_handle "^script".intern do
       @value.script.deep_copy
     end
+    
+    
+    duck_handle "^ticks".intern do
+      Int.new( @value.ticks )
+    end
+    
   end
 end
\ No newline at end of file
diff --git a/lib/script_class.rb b/lib/script_class.rb
index 92ae6b6..9ec9348 100644
--- a/lib/script_class.rb
+++ b/lib/script_class.rb
@@ -1,10 +1,10 @@
 #encoding: utf-8
-
-def script(value="")
-  Script.new(value)
-end
-
 module Duck
+  def script(value="")
+    Script.new(value)
+  end
+  
+  
   class Script < Item
     attr_accessor :value
   
diff --git a/lib/span_class.rb b/lib/span_class.rb
index 57aa632..c7be0cc 100644
--- a/lib/span_class.rb
+++ b/lib/span_class.rb
@@ -10,6 +10,11 @@ def initialize(start_value, end_value)
       @needs = []
     end
     
+    def deep_copy
+      Span.new(@start_value, @end_value)
+    end
+    
+    
     def to_s
       "(#{@start_value}..#{@end_value})"
     end
diff --git a/lib/variable_class.rb b/lib/variable_class.rb
index f59447e..f058bc1 100644
--- a/lib/variable_class.rb
+++ b/lib/variable_class.rb
@@ -1,41 +1,50 @@
 #encoding: utf-8
 
-def variable(key, value)
-  Variable.new(key,value)
-end
-
 
 module Duck
+  def variable(key, value)
+    Variable.new(key,value)
+  end
+  
+  
   class Variable < Item
     attr_reader :key
     attr_accessor :value
-  
+    
+    
     def initialize(key, value)
       raise ArgumentError, "Variable key not a Symbol or String" unless
         [Symbol, String].include?(key.class)
       raise ArgumentError, "Variable value not a Duck::Item" unless
         value.kind_of?(Item)
-    
+      
       @key = key.intern
       @value = value
       @needs = []
-    
+      
       define_singleton_method @key do
         [self,@value.deep_copy]
       end
     end
-  
+    
+    
+    def deep_copy
+      Variable.new(@key, @value)
+    end
+    
+    
     def recognize_message?(string)
       signal = string.intern
       signal == @key || self.class.recognized_messages.include?(signal)
     end
-  
+    
+    
     def to_s
       "#{@key.inspect}=#{@value.inspect}"
     end
-  
+    
     # DUCK METHODS  
-  
+    
     duck_handle :rebind do
       Closure.new(["be"],"#{@key}.bind(?)") {|new_value| Variable.new(@key, new_value)}
     end
diff --git a/notes/evaluation_steps.rb b/notes/evaluation_ticks.rb
similarity index 91%
rename from notes/evaluation_steps.rb
rename to notes/evaluation_ticks.rb
index 04433af..7e77a94 100644
--- a/notes/evaluation_steps.rb
+++ b/notes/evaluation_ticks.rb
@@ -47,11 +47,11 @@ def random_script(how_many, source_list=@everything)
       pts = len*(10)
       script = random_script(pts)
       begin
-        Timeout::timeout(10) do
+        Timeout::timeout(120) do
           puts"#{pts}, #{interpreter(script:script, binder:{x:int(3)}).run.ticks}"
         end
-      rescue Timeout::Error
-        puts "TIMEOUT: #{script.inspect}"
+      rescue Exception => e
+        puts "ERROR:#{e.message} -- #{e.backtrace} #{script.inspect}"
         raise
       end
     rescue
diff --git a/notes/iterator_sketch.txt b/notes/iterator_sketch.txt
index e5f4feb..33b1824 100644
--- a/notes/iterator_sketch.txt
+++ b/notes/iterator_sketch.txt
@@ -3,7 +3,7 @@ Special messages:
   :run
   :halt
   :reset
-  :ff
+  :fast_forward
   :contents
   :start_value
   :end_value
@@ -11,42 +11,31 @@ Special messages:
   :increment
   - a bunch of List methods (:shatter, )
 
-
-SpanIterator
-  "iterate over a range of integers"
-  something like: int(a).through(int(b)) do |Local| Item
-  
-  creates an Enumerator
-  @index starts at int(a)
-  @index ends at int(b)
-  every step:
-    binds local:=int as a Variable
-    increments index
-    produces [self(updated), Variable, Item] in that order
-
-
-
-"iterate over a range of Decimals"
-something like: decimal(a).through(decimal(b)).int(c).times do |Local| Item
-
-    creates an Enumerator
-    @index starts at decimal(a)
-    @index ends at decimal(b)
-    @increment is |b-a|/int(c)
-    every step:
-      binds local:=@index as a Variable
-      increments index by one increment
-      produces [self(updated), Variable, Item] in that order
-
-
-"iterate over the elements of a list"
-something like: list.each do |local| Item
-  
-  creates an Enumerator
-  no @index used
-  every step:
-    snips off first (remaining) element of list
-    binds local:=element as a Variable
-    produces [self(updated), Variable, Item]
+Int.times_do
+  creates an Iterator, with
+    Span (0..int.value)
+    _i = 0
+    increment = +1
+    contents = any item
+  step:
+    produces [self, _i, contents].flatten
     
-
+    
+List.each
+  creates an Iterator with
+    Span (0..list.length)
+    _i = 0
+    increment = +1
+    contents = list contents
+  step:
+    produces [self, _i, contents[i]].flatten
+    
+    
+Span.each
+  creates an Iterator with
+    Span = the span
+    _i = start_value
+    increment = some float
+    contents = nil
+  step:
+    produces [self, _i, (nil)].flatten
\ No newline at end of file
diff --git a/notes/recursion_effects.pdf b/notes/recursion_effects.pdf
new file mode 100644
index 0000000..b4d7971
Binary files /dev/null and b/notes/recursion_effects.pdf differ
diff --git a/notes/sandbox_testing.rb b/notes/sandbox_testing.rb
index 43ca1bb..6396305 100644
--- a/notes/sandbox_testing.rb
+++ b/notes/sandbox_testing.rb
@@ -2,7 +2,7 @@
 require_relative '../lib/duck'
 include Duck
 
-bad_boy = 
+bad_boy = interpreter(script: "to_int below -8.2 to_interpreter to_interpreter each []= 4 F to_span x ≥ 8 F _o x _v eql 4.6 cover? count ^rescript shatter shift ∨ pop 7 ≤ push 6 - -7 zap push map _s -1 inc cover? give flatten bundle above trunc to_interpreter rotate ∨ above to_script _k each eql _j < do ∧ be T -5.1 _w x ∧ ∪ bind count F ^fork to_bool zap push be _q 1 each ^ticks bundle above useful F halt know? to_interpreter to_binder -3 push F each map inc x -8.4 x map pop T to_span 3 x _g 2.5 neg infold_down x F greedy useful copy ^rescript x x F F F F flatten emit each 2.2 map F to_binder 5 9 _p -5 greedy? x F -0.8 x ∩ greedy each to_script ∪ + lowercase x F 3 + _y ^greedy= empty halt rewrap_by unshift x ^rescript copies x -1.3 halt 1.3 lowercase neg 4 _s ^rescript T flatten ^script push 1.5 ^greedy= ^greedy= F T to_binder 8", binder:{x:int(3)})
 
 
 
@@ -18,12 +18,30 @@
 
 
 
+
+
 # JUST SLOW
 
+interpreter(script: "below -7.2 T above cover? flatten to_span fold_down 8 x ∨ if ^script greedy? infold_down emit ∧ be - neg 0.5 keep snap ^script swap if empty -4.9 infold_down ¬ x x x ≥ T cover? T x -7.6 to_binder 5.7 zap pop 7.4 to_decimal ^rescript _v F T _s snap step emit -3 to_interpreter push -4 ≥ users ^script ^greedy= ∧ x keep length -8 ^ticks step shift map step emit rebind ^rescript -5 ^script F -7 F + x infold_up < infold_up snap do x wrap ^greedy= bundle", binder:{x:int(30)})
+
 
 
 # FIXED ?
 
+# interpreter(script: "F F - to_span 1.8 wrap ^length T pop fold_down -9 x _k x ^fork -7 map [] emit shatter x trunc _m ^script step + count_by copy > swap copy _f T x lowercase 5.5 to_int ∪ F swap F fold_down x 0.2 -4.1 to_bool inc be ∪ infold_down _u length ^script ≤ 2 F _q to_span _g shatter ^rescript fold_down below _a ^quote infold_down count_by _y -3.5 ^greedy= rand _s rebind < x neg 7.6 shatter -3 useful T below - empty ≥ F inc -7 copies halt to_list F 8 infold_up each count lowercase neg x length ∪ copy ^script bind > run index= _i ^ticks < _s _j _f ^fork to_binder ∪ users useful -0.3 fold_down 4.2 fold_down > < F x x _y < if < ^fork ^length -2.0 again count ≥ ^ticks pop step _f rebind cover? x 4 give count_by ∨ ^ticks reverse * 8 snap T -3.9 _h greedy useful give T", binder:{x:int(3)})
+
+# interpreter(script: "_q to_span > T fold_down 2 ∧ 5 map if ^fork x cover? T ≤ step F T -4 ^length -9 greedy? _i 6.9 fold_down fold_up [] 8.5 shift x - to_interpreter to_binder each to_script F rewrap_by _g x ≤ reverse known[] ≥ ∧ T to_assembler < be neg pop map T to_span ÷ + wrap inc T each infold_down each known[] push 0 rebind count _c 7.0 _z halt x to_binder _h -6 to_assembler below ÷ 0 ∩ ∪ useful rotate T 0.7 ^greedy= fold_up x to_decimal ∪ -8 -5 to_int x above run times_do above fold_down -3.2 ^fork cover? 2 to_decimal F again infold_up halt ^rescript if to_interpreter F x 1 to_decimal ÷ -1.6 each T wrap to_assembler length to_interpreter x _j keep [] length rand unshift > if know? do -9.8 users x count ∧ ∧ F be bundle shatter length x copy -8 T swap -2.9 snap T fold_up emit ^length ^quote map trunc again bundle F rotate ^length x halt F 9 know? 2.6 -5.6 reverse < F -0.3 greedy ^script reverse give to_script _z known[] _h fold_up _c fold_up emit to_interpreter _z F x", binder:{x:int(3)})
+
+# interpreter(script: "¬ -7 x shatter F bind above ÷ ≤ flatten infold_up _o trunc ^script 9.3 - T to_decimal x ¬ rotate eql -7 fold_up cover? snap ∧ + -3 _c bundle inc 6.9 _t emit x to_span to_list -2.2 to_list []= -1 -3.1 wrap known[] eql halt do 3 > keep trunc below 4.1 4.4 to_int < 1.8 to_span inc -1 _t keep > F above trunc _h again infold_down empty _u ^length count bundle -9 [] swap x * 8.7 to_assembler known[] pop step ^ticks _z do _t ungreedy F -4 bind - map T each T rewrap_by -0 greedy? ∪ to_bool 7 trunc -1.2 give x ≥ to_span bind 4.5 -1 _j ^fork zap neg map push bundle", binder:{x:int(30)})
+
+# interpreter(script: "∪ T to_list know? empty F times_do -1 ^rescript _f below times_do ungreedy 2.5 ^fork neg again _s copies each cover? trunc ^rescript to_span -8.0 ^ticks to_decimal 9.0 T ^fork 4 0 greedy? fold_down ^greedy= 6.3 F rand unshift ≤ x F 5.0 6 _t rotate shatter each eql -5 users ^rescript length -8 step unshift T run keep ∩", binder:{x:int(30)})
+
+# interpreter(script: "4.6 rotate ∪ _g swap 6 -9 _p rebind _y -8.6 []= to_int T run -6.6 emit _l 8.6 4 lowercase keep users x -9.4 times_do T flatten neg x -1 T useful x x greedy? zap to_assembler x x to_binder rotate 8.4 to_span ^length 1.2 rewrap_by ^script F times_do ^quote halt copy ^length rand _s push T T -2 inc keep 6 3.3 -6 to_interpreter + _x neg unshift - x ∨ reverse x ≥ cover? ≤ greedy x bundle _c eql T T halt cover? [] fold_down T F greedy ^length to_interpreter give fold_down empty -9 shatter T + ¬ ∧ give F 4 to_decimal ^rescript _d _d empty _o -3 shatter greedy -6 x < -2 rebind neg ^fork keep shift lowercase ^rescript shatter _g _k pop shift greedy? push times_do ∩ 6.3 ≥ if neg to_list ∨ 2.8 snap halt _i x useful 0 x map x _x lowercase x empty T push length lowercase to_binder below F step 7.5 T step copies ≤ copy to_interpreter", binder:{x:int(30)})
+
+#interpreter(script: "empty []= fold_up swap F infold_up rand _n keep ^greedy= lowercase greedy? * x rewrap_by [] shatter -1.5 ^fork _c 7.9 to_int to_decimal T below ÷ ungreedy ^length F x T _t ^greedy= ∩ times_do run x neg wrap 9 -4.6 snap 9 to_binder _u x -2.6 bundle ungreedy be shift greedy? know? -9 x greedy? neg x rewrap_by keep ^length []= fold_down x 1 rotate rewrap_by 1.9 to_int rand bind to_assembler _d -8.6 x ≥ cover? rebind above wrap map _k _h to_interpreter x _c inc zap push bind", binder:{x:int(-30)})
+
+# interpreter(script: "fold_down -1 ^greedy= copy -9 x unshift ^length F _o x greedy ÷ 7.5 unshift fold_down -5 x swap shift below reverse keep 2 _t 7 known[] empty copies push ≤ times_do 8.6 give _b greedy x ^rescript greedy give fold_up x known[] shift _w fold_up below give emit rotate times_do x greedy? trunc rand x ungreedy + know? greedy? run _e to_int 4 x to_list x lowercase 9 x below to_binder ^greedy= x rotate -7.2 ^quote infold_up rewrap_by x fold_down rebind to_span to_int _x x if _t infold_down shatter give useful ¬ if infold_up to_span T rand infold_up bundle to_decimal 2.0 emit [] rand pop inc > halt below bind > bind rand do neg x x ∨ x 6.5 < to_bool keep run x to_span step ungreedy F do ∨ infold_down _x _j -1 reverse rotate x 8 greedy? 1 be ^script run rebind reverse T _v to_span T to_decimal x 7.3 give x -2.1 x fold_up ∨ _t F ≤ zap wrap T give 8.2 T _a * x do to_binder -9 flatten 4.1 ^greedy= _m _o", binder:{x:int(30)})
+
 # interpreter(script: "[] x 9 1.6 be unshift F -6 ^length pop 7.8 lowercase - fold_down T -2.7 to_assembler emit cover? above rand 1.3 rewrap_by 9 _y _g to_decimal ∨ infold_down F _f x ≤ greedy run pop * ≤ _c rand to_int 1 x below infold_up unshift ÷ + fold_up x greedy -0.9 fold_up -8 ∧ to_bool 4 ungreedy -7.7 _e - fold_up _x known[] _v infold_down rotate 5 x infold_down F []= 7 []= _z x swap _m x _g to_assembler to_int map _s unshift x to_bool ^script swap ∪ eql _b bind F T eql -2 fold_down useful copies _k -8 _m zap ^script -7.3 5 eql x 7 known[] -0.6 ≤ x _e ^rescript map push cover? x rewrap_by push 9 known[] x ^rescript wrap neg ^rescript wrap x cover? -2 x shift below _w step 4.3 x -2.8 greedy ^fork x ∪ rand empty to_interpreter x 9.0 bundle ^script T 2.5 ^rescript F give - halt ÷ map F ungreedy < trunc 2.1 empty fold_down _l F", binder:{x:int(30)})
 
 # interpreter(script: "7.4 T if to_binder ^rescript shatter -8.5 _a fold_up _z unshift ¬ -0.1 ^rescript 9.2 fold_down ≤ reverse T _r 4.9 ^script greedy ≤ _x x ∩ to_span give known[] ≤ halt T 7 T 6.5 snap users ^length -7 to_span - []= to_list -0.3 know? T 0.9 infold_down _p halt 0.8 empty * greedy? -2.8 -8 if [] give + x 7 ∪ ungreedy _m F []= T _m F ¬ _n _b to_binder _h -2 -9 -4.4 _n -6.3 ∪ flatten dec _o infold_down * fold_down infold_up rewrap_by inc empty [] x _v rewrap_by to_bool > _h ∩ ^fork wrap emit rewrap_by _p below users empty neg F zap x ^length lowercase emit rewrap_by cover? x map rand -2 if > cover? x dec _a to_list F lowercase ÷ do 9 x x cover? > ^script ^rescript to_assembler + -4 2.7 to_decimal [] rotate known[] be to_bool copy eql flatten _b ∩ bundle step -5.9 bind T 7 to_binder if F fold_down known[] if ^script x neg flatten step above above x infold_up to_bool rand 2 users useful 0 swap to_interpreter _x emit lowercase ¬ ^length 4.0 to_list", binder:{x:int(30)})
diff --git a/spec/_core/tracing_spec.rb b/spec/_core/tracing_spec.rb
deleted file mode 100644
index 684a6ab..0000000
--- a/spec/_core/tracing_spec.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-#encoding: utf-8
-require_relative '../spec_helper'
-
-describe "Tracing behavior" do
-  describe "Duck::Trace" do
-  end
-end
\ No newline at end of file
diff --git a/spec/assemblers/messages/greedy_message_spec.rb b/spec/assemblers/messages/greedy_message_spec.rb
index cbd4349..add72b4 100644
--- a/spec/assemblers/messages/greedy_message_spec.rb
+++ b/spec/assemblers/messages/greedy_message_spec.rb
@@ -15,7 +15,7 @@
       ungreedy.greedy_flag = false
       ungreedy.run
       ungreedy.inspect.should == "[:*, 9 ::]" 
-
+      
       ungreedy.greedy
       ungreedy.buffer = [int(2)]
       ungreedy.run
diff --git a/spec/binders/binder_class_spec.rb b/spec/binders/binder_class_spec.rb
index 3e8bc3c..c328514 100644
--- a/spec/binders/binder_class_spec.rb
+++ b/spec/binders/binder_class_spec.rb
@@ -59,9 +59,10 @@
       @two_things.produce_respondent("¬").inspect.should == "F"
     end
     
-    it "should be consumed if it responded itself to the message" do
+    it "should be consumed (producing a deep_copy) if it responded itself to the message" do
       @two_things.personally_recognizes?("length").should == true
-      @two_things.produce_respondent("length").should == @two_things
+      @two_things.produce_respondent("length").should_not === @two_things
+      @two_things.produce_respondent("length").inspect.should == @two_things.inspect
     end
     
     it "should work in situ" do
diff --git a/spec/bools/messages/to_script_message_spec.rb b/spec/bools/messages/to_script_message_spec.rb
new file mode 100644
index 0000000..b645827
--- /dev/null
+++ b/spec/bools/messages/to_script_message_spec.rb
@@ -0,0 +1,15 @@
+#encoding: utf-8
+require_relative '../../spec_helper'
+
+describe "Bool" do
+  describe "to_script" do
+    it "should be recognized by Bool items" do
+      Bool.recognized_messages.should include :to_script
+    end
+    
+    it "should return a Script with 'T' or 'F'" do
+      bool(F).to_script.value.should == "F"
+      bool(T).to_script.inspect.should == "«T»"
+    end
+  end
+end
diff --git a/spec/decimals/messages/count_by_message_spec.rb b/spec/decimals/messages/count_by_message_spec.rb
new file mode 100644
index 0000000..f187e50
--- /dev/null
+++ b/spec/decimals/messages/count_by_message_spec.rb
@@ -0,0 +1,41 @@
+#encoding: utf-8
+require_relative '../../spec_helper'
+
+describe "Decimal" do
+  describe ":count_by message" do
+    it "should be recognized by Decimal items" do
+      Decimal.recognized_messages.should include :count_by
+    end
+    
+    it "should return a Closure that wants another Int" do
+      counter = decimal(8.1).count_by
+      counter.should be_a_kind_of Closure
+      counter.needs.should == ["neg"]
+    end
+    
+    it "should produce the expected output (counting!)" do
+      interpreter(script:"1.1 3.1 count_by").run.inspect.should == 
+        "[0.0, 1.1, 2.2, (0.0..~(3.1)..3.1)=>[] :: :: «»]"
+    end
+    
+    it "should be willing to use an Int as an increment as well" do
+      interpreter(script:"2 5.1 count_by").run.inspect.should == 
+        "[0.0, 2.0, 4.0, (0.0..~(5.1)..5.1)=>[] :: :: «»]"
+    end
+    
+    it "should produce downwards counting if negative" do
+      interpreter(script:"2.1 -6.7 count_by").run.inspect.should ==
+        "[0.0, -2.1, -4.2, -6.300000000000001, (0.0..~(-6.7)..-6.7)=>[] :: :: «»]"
+    end
+    
+    it "should flip around if it's a negative increment" do
+      interpreter(script:"-2.25 13.2 count_by").run.inspect.should ==
+        "[0.0, 2.25, 4.5, 6.75, 9.0, 11.25, (0.0..~(13.2)..13.2)=>[] :: :: «»]"
+    end
+    
+    it "should run a long time when it's a zero increment" do
+      interpreter(script:"0.0 3.0 count_by", max_ticks:100).run.inspect.should include
+        ":: err:[over-complex: 102 ticks] :: «»]"
+    end
+  end
+end
diff --git a/spec/decimals/messages/count_message_spec.rb b/spec/decimals/messages/count_message_spec.rb
new file mode 100644
index 0000000..b8f0c15
--- /dev/null
+++ b/spec/decimals/messages/count_message_spec.rb
@@ -0,0 +1,31 @@
+#encoding: utf-8
+require_relative '../../spec_helper'
+
+describe "Decinal" do
+  describe ":count message" do
+    it "should be recognized by Decimal items" do
+      Decimal.recognized_messages.should include :count
+    end
+    
+    it "should return a running Iterator that has start 0 and end the value of the Int" do
+      counter = int(8.0).count
+      counter.should be_a_kind_of Array
+      counter[0].start.should == 0
+      counter[0].end.should == 8
+    end
+    
+    it "should return an Iterator with :response set to :index" do
+      decimal(8.4).count[0].response.should == :index
+    end
+    
+    it "should produce the expected output (counting!)" do
+      interpreter(script:"4.2 count").run.inspect.should == 
+        "[0.0, 1.0, 2.0, 3.0, 4.0, (0.0..~(4.2)..4.2)=>[] :: :: «»]"
+    end
+    
+    it "should produce downwards counting if negative" do
+      interpreter(script:"-6.0 count").run.inspect.should ==
+        "[0.0, -1.0, -2.0, -3.0, -4.0, -5.0, (0.0..~(-6.0)..-6.0)=>[] :: :: «»]"
+    end
+  end
+end
diff --git a/spec/ints/messages/count_by_message_spec.rb b/spec/ints/messages/count_by_message_spec.rb
new file mode 100644
index 0000000..88a9e0f
--- /dev/null
+++ b/spec/ints/messages/count_by_message_spec.rb
@@ -0,0 +1,33 @@
+#encoding: utf-8
+require_relative '../../spec_helper'
+
+describe "Int" do
+  describe ":count_by message" do
+    it "should be recognized by Int items" do
+      Int.recognized_messages.should include :count_by
+    end
+    
+    it "should return a Closure that wants another Int" do
+      counter = int(8).count_by
+      counter.should be_a_kind_of Closure
+      counter.needs.should == ["inc"]
+    end
+    
+    it "should produce the expected output (counting!)" do
+      interpreter(script:"2 4 count_by").run.inspect.should == "[0, 2, (0..4..4)=>[] :: :: «»]"
+    end
+    
+    it "should produce downwards counting if negative" do
+      interpreter(script:"2 -6 count_by").run.inspect.should == "[0, -2, -4, (0..-6..-6)=>[] :: :: «»]"
+    end
+    
+    it "should work for negative increments" do
+      interpreter(script:"-2 3 count_by").run.inspect.should == "[0, 2, (0..3..3)=>[] :: :: «»]"
+    end
+    
+    it "should run a long time when it's a zero increment" do
+      interpreter(script:"0 3 count_by", max_ticks:100).run.inspect.should include
+        ":: err:[over-complex: 102 ticks] :: «»]"
+    end
+  end
+end
diff --git a/spec/ints/messages/count_message_spec.rb b/spec/ints/messages/count_message_spec.rb
new file mode 100644
index 0000000..2df2841
--- /dev/null
+++ b/spec/ints/messages/count_message_spec.rb
@@ -0,0 +1,29 @@
+#encoding: utf-8
+require_relative '../../spec_helper'
+
+describe "Int" do
+  describe ":count message" do
+    it "should be recognized by Int items" do
+      Int.recognized_messages.should include :count
+    end
+    
+    it "should return a running Iterator that has start 0 and end the value of the Int" do
+      counter = int(8).count
+      counter.should be_a_kind_of Array
+      counter[0].start.should == 0
+      counter[0].end.should == 8
+    end
+    
+    it "should return an Iterator with :response set to :index" do
+      int(8).count[0].response.should == :index
+    end
+    
+    it "should produce the expected output (counting!)" do
+      interpreter(script:"4 count").run.inspect.should == "[0, 1, 2, 3, (0..4..4)=>[] :: :: «»]"
+    end
+    
+    it "should produce downwards counting if negative" do
+      interpreter(script:"-6 count").run.inspect.should == "[0, -1, -2, -3, -4, -5, (0..-6..-6)=>[] :: :: «»]"
+    end
+  end
+end
diff --git a/spec/ints/messages/times_do_message_spec.rb b/spec/ints/messages/times_do_message_spec.rb
index 1ada5dc..aa5dfa4 100644
--- a/spec/ints/messages/times_do_message_spec.rb
+++ b/spec/ints/messages/times_do_message_spec.rb
@@ -12,7 +12,7 @@
       int(8).times_do.needs.should == ["be"]
     end
     
-    it "should produce an Iterator item and a :run" do
+    it "should produce running Iterator" do
       interpreter(script:"9.2 1 times_do").run.inspect.should == "[9.2, (0..1..1)=>[9.2] :: :: «»]"
     end
     
diff --git a/spec/iterators/iterator_class_spec.rb b/spec/iterators/iterator_class_spec.rb
index e4e6083..a6222f0 100644
--- a/spec/iterators/iterator_class_spec.rb
+++ b/spec/iterators/iterator_class_spec.rb
@@ -12,6 +12,10 @@
       ns.contents.should == []
     end
     
+    it "should have a :response mode to determine what to return" do
+      Iterator.new.response.should == :contents
+    end
+    
     it "should set the index to the start_value if not specified" do
       Iterator.new(start:11, end:8).index.should == 11
     end
diff --git a/spec/iterators/messages/again_message_spec.rb b/spec/iterators/messages/again_message_spec.rb
new file mode 100644
index 0000000..fb3bca3
--- /dev/null
+++ b/spec/iterators/messages/again_message_spec.rb
@@ -0,0 +1,34 @@
+#encoding: utf-8
+require_relative '../../spec_helper'
+
+describe "Iterator" do
+  describe "again" do
+    it "should be recognized by Iterator items" do
+      Iterator.recognized_messages.should include :again
+    end
+    
+    
+    it "should return itself if the index is outside the range, while resetting the index to the close end" do
+      askew = Iterator.new(start:0, end:3, index:9)
+      askew.again.should == askew
+      askew.index.should == 3
+      
+      askew = Iterator.new(start:0.1, end:3.0, index:-9.0)
+      askew.again.should == askew
+      askew.index.should == 0.1
+    end
+    
+    
+    it "should not change the increment" do
+      four_threes = Iterator.new(start:0, end:3, contents:[int(3)])
+      four_threes.again.inspect.should == "[(0..0..3)=>[3], 3]"
+      four_threes.again.inspect.should == "[(0..0..3)=>[3], 3]"
+    end
+    
+    
+    it "should return an Array containing only itself if nothing is bound" do
+      four_threes = Iterator.new(start:0, end:3)
+      four_threes.again.inspect.should == "[(0..0..3)=>[]]"
+    end
+  end
+end
diff --git a/spec/iterators/messages/inherited_list_messages_spec.rb b/spec/iterators/messages/inherited_list_messages_spec.rb
index 6cb49f1..e1642da 100644
--- a/spec/iterators/messages/inherited_list_messages_spec.rb
+++ b/spec/iterators/messages/inherited_list_messages_spec.rb
@@ -22,7 +22,7 @@
     
     
     describe ":+" do
-      it "should respond to :+ as a List does, concatenating the contents" do
+      it "should respond to :+ as a List does, concatenating the contents into itself" do
         itty = Iterator.new(start:3, end:11, contents:[bool(F), message(:foo), int(-99)])
         bitty = Iterator.new(start:1, end:-22, contents:[message(:bar)])
         
@@ -226,8 +226,5 @@
           "[(:*, λ(2 + ?,[\"neg\"])), (:length) :: :: «»]"
       end
     end
-    
-    
-    
   end
 end
diff --git a/spec/iterators/messages/iterator=_message_spec.rb b/spec/iterators/messages/iterator=_message_spec.rb
new file mode 100644
index 0000000..7fc6ead
--- /dev/null
+++ b/spec/iterators/messages/iterator=_message_spec.rb
@@ -0,0 +1,26 @@
+#encoding: utf-8
+require_relative '../../spec_helper'
+
+describe "Iterator" do
+  describe "the :index= message for Iterators" do
+    it "should be something an Iterator recognizes" do
+      Iterator.recognized_messages.should include(:index=)
+    end
+    
+    it "should return a Closure looking for a Number" do
+      setter = Iterator.new.send(:index=)
+      setter.should be_a_kind_of(Closure)
+      setter.needs.should == ["neg"]
+    end
+    
+    it "should set the index to the value of the arg it grabs" do
+      reset = interpreter(script:"index= 3", contents:[Iterator.new]).run
+      reset.contents[0].index.should == 3
+    end
+    
+    it "should be willing to set the index of an integer Iterator to any Number value" do
+      reset = interpreter(script:"index= 3.8", contents:[Iterator.new]).run
+      reset.contents[0].index.should == 3.8
+    end
+  end
+end
diff --git a/spec/iterators/messages/rewrap_by_message_spec.rb b/spec/iterators/messages/rewrap_by_message_spec.rb
index a89eb76..750f7cf 100644
--- a/spec/iterators/messages/rewrap_by_message_spec.rb
+++ b/spec/iterators/messages/rewrap_by_message_spec.rb
@@ -17,5 +17,11 @@
       interpreter(script:"3 rewrap_by", contents:[makes_numbers]).run.inspect.should ==
         "[(3..3..5)=>[0, 1, 2], (3..3..5)=>[3, 4, 5], (3..3..5)=>[6, 7, 8], (3..3..5)=>[9, 10, 11] :: :: «»]"
     end
+    
+    it "should retain the response mode in all results" do
+      makes_a_number = Iterator.new(start:3, end:5, contents:(0..11).collect {|i| int(i)}, :response => :element)
+      chunked = interpreter(script:"3 rewrap_by", contents:[makes_a_number]).run
+      chunked.contents.each {|iterator| iterator.response.should == :element}
+    end
   end
 end
diff --git a/spec/iterators/messages/run_message_spec.rb b/spec/iterators/messages/run_message_spec.rb
index 0b92a66..6d6d553 100644
--- a/spec/iterators/messages/run_message_spec.rb
+++ b/spec/iterators/messages/run_message_spec.rb
@@ -29,12 +29,18 @@
         loopy.inspect.should == "[11, 2, 2, 2, 2, (1..5..5)=>[2] :: :: «»]"
     end
     
-    it "should execute the bound_item" do
+    it "should produce the expected contents, based on the :response mode" do
       loopy = interpreter(script:"11 run",
         contents:[Iterator.new(start:1,end:5,contents:[message(:zap)])])
         loopy.run
         loopy.inspect.should == "[11, (1..5..5)=>[:zap] :: :: «»]"
     end
     
+    it "should work for counters" do
+      counter = Iterator.new(start:9.25, end:223.25, inc:53.0, :response => :index)
+      i = interpreter(script:"run", contents:[counter]).run
+      i.inspect.should == "[9.25, 62.25, 115.25, 168.25, 221.25, (9.25..~(223.25)..223.25)=>[] :: :: «»]"
+    end
+    
   end
 end
diff --git a/spec/iterators/messages/snap_message_spec.rb b/spec/iterators/messages/snap_message_spec.rb
index 6d0a45b..25a63ad 100644
--- a/spec/iterators/messages/snap_message_spec.rb
+++ b/spec/iterators/messages/snap_message_spec.rb
@@ -17,5 +17,11 @@
       snap_it = interpreter(script:"5 snap", contents:[makes_numbers]).run
       snap_it.inspect.should == "[(3..3..5)=>[0, 1, 2, 3, 4], (3..3..5)=>[5, 6, 7, 8, 9, 10, 11] :: :: «»]"
     end
+    
+    it "should retain the :response mode in both" do
+      makes_a_number = Iterator.new(start:3, end:5, contents:(0..11).collect {|i| int(i)}, :response => :element)
+      snap_it = interpreter(script:"5 snap", contents:[makes_a_number]).run
+      snap_it.contents.each {|iterator| iterator.response.should == :element}
+    end
   end
 end
diff --git a/spec/iterators/messages/step_message_spec.rb b/spec/iterators/messages/step_message_spec.rb
index e9d7e49..500b66c 100644
--- a/spec/iterators/messages/step_message_spec.rb
+++ b/spec/iterators/messages/step_message_spec.rb
@@ -7,7 +7,7 @@
       Iterator.recognized_messages.should include :step
     end
     
-    it "should return itself if the index is outside the range, while resetting the index to the close end" do
+    it "should return JUST itself if the index is outside the range, resetting the index to the close end" do
       askew = Iterator.new(start:0, end:3, index:9)
       askew.step.should == askew
       askew.index.should == 3
@@ -17,25 +17,79 @@
       askew.index.should == 0
     end
     
-    it "should add the inc to the index and return itself FLAT with its contents otherwise" do
-      four_threes = Iterator.new(start:0, end:3, contents:[int(3)])
-      four_threes.step.inspect.should == "[(0..1..3)=>[3], 3]"
-      four_threes.step.inspect.should == "[(0..2..3)=>[3], 3]"
-      four_threes.step.inspect.should == "[(0..3..3)=>[3], 3]"
-      four_threes.step.inspect.should == "(0..3..3)=>[3]"
+    describe "the :response mode" do
+      context ":response => :contents" do
+        it "should add the inc to the index and return itself and its contents" do
+          four_threes = Iterator.new(start:0, end:3, contents:[int(3), int(4)])
+          four_threes.step.inspect.should == "[(0..1..3)=>[3, 4], 3, 4]"
+          four_threes.step.inspect.should == "[(0..2..3)=>[3, 4], 3, 4]"
+          four_threes.step.inspect.should == "[(0..3..3)=>[3, 4], 3, 4]"
+          four_threes.step.inspect.should == "(0..3..3)=>[3, 4]"
+        end
+      end
       
+      context ":response => :element" do
+        before(:each) do
+          @nums = Iterator.new(start:0, end:6, contents:[int(1),int(2),int(3),int(4)],:response => :element)
+        end
+        
+        it "should add the inc to the index and return itself and the idx element of its contents" do
+          @nums.step.inspect.should == "[(0..1..6)=>[1, 2, 3, 4], 1]"
+        end
+        
+        it "should use the index modulo the number of contents elements" do
+          @nums.step.inspect.should == "[(0..1..6)=>[1, 2, 3, 4], 1]"
+          @nums.step.inspect.should == "[(0..2..6)=>[1, 2, 3, 4], 2]"
+          @nums.step.inspect.should == "[(0..3..6)=>[1, 2, 3, 4], 3]"
+          @nums.step.inspect.should == "[(0..4..6)=>[1, 2, 3, 4], 4]"
+          @nums.step.inspect.should == "[(0..5..6)=>[1, 2, 3, 4], 1]"
+        end
+        
+        it "should work 'the same way' for Decimal spans" do
+          odd = Iterator.new(start:-3.4, end:17.3, inc:1.1, contents:[message(:a), message(:b)], :response => :element)
+          odd.step.inspect.should == "[(-3.4..~(-2.3)..17.3)=>[:a, :b], :a]"
+          odd.step.inspect.should == "[(-3.4..~(-1.2)..17.3)=>[:a, :b], :b]"
+          odd.step.inspect.should == "[(-3.4..~(-0.1)..17.3)=>[:a, :b], :a]"
+          odd.step.inspect.should == "[(-3.4..~(1.0)..17.3)=>[:a, :b], :b]"
+        end
+        
+        it "should work for empty contents" do
+          nothin = Iterator.new(end:3, contents:[], :response => :element)
+          lambda{ nothin.step }.should_not raise_error
+          nothin.step.inspect.should == "[(0..2..3)=>[]]"
+        end
+      end
+    end
+    
+    
+    describe "the index_only flag" do
+      it "should just return the (pre-update) index, not any elements of the contents" do
+        counter = Iterator.new(start:-12,end:3,:response => :index)
+        counter.step.inspect.should == "[(-12..-11..3)=>[], -12]"
+        counter.step.inspect.should == "[(-12..-10..3)=>[], -11]"
+      end
+      
+      it "should work for floating-point ranges" do
+        ranger = Iterator.new(start:0.113,end:3.112,inc:2.2,:response => :index)
+        ranger.step.inspect.should == "[(0.113..~(2.313)..3.112)=>[], 0.113]"
+        ranger.step.inspect.should == "[(0.113..~(4.513)..3.112)=>[], 2.313]"
+        ranger.step.inspect.should == "(0.113..~(3.112)..3.112)=>[]" # done
+      end
     end
     
     it "should detect when the sign of the inc and the order of extremes needs changing" do
-      down = Iterator.new(start:10,end:3, index:7, contents:[bool(F)])
+      down = Iterator.new(start:10, end:3, index:7, contents:[bool(F)])
       down.step.inspect.should == "[(10..6..3)=>[F], F]"
       
-      down = Iterator.new(start:10,end:3, inc:-2, contents:[bool(F)])
+      down = Iterator.new(start:10, end:3, inc:-2, contents:[bool(F)])
       down.step.inspect.should == "[(10..8..3)=>[F], F]"
       
+      down = Iterator.new(start:10.0, end:3.1, inc:-3.1, contents:[bool(F)])
+      down.step.inspect.should == "[(10.0..~(6.9)..3.1)=>[F], F]"
     end
     
-    it "should return a an empty Array item if nothing is bound" do
+    
+    it "should return an Array containing just itself (updated) if nothing is bound" do
       four_threes = Iterator.new(start:0, end:3)
       four_threes.step.inspect.should == "[(0..1..3)=>[]]"
       four_threes.step.inspect.should == "[(0..2..3)=>[]]"
diff --git a/spec/iterators/messages/union_message_spec.rb b/spec/iterators/messages/union_message_spec.rb
index d7a72f7..a1906b8 100644
--- a/spec/iterators/messages/union_message_spec.rb
+++ b/spec/iterators/messages/union_message_spec.rb
@@ -26,5 +26,11 @@
       interpreter(script:"∪", contents:[i2,i1]).run.inspect.should ==
         "[(0..0..10)=>[11, 9, 8] :: :: «»]"
     end
+    
+    it "should keep the calling Iterator's :response mode" do
+      i1 = Iterator.new(start:0,end:10,contents:[int(8),int(9)], :response => :index)
+      i2 = Iterator.new(start:-2,end:-12, contents:[int(11),int(9)])
+      interpreter(script:"∪", contents:[i2,i1]).run.contents[0].response.should == :index
+    end
   end
 end
diff --git a/spec/lists/list_class_spec.rb b/spec/lists/list_class_spec.rb
index f3ce2b5..40c3f62 100644
--- a/spec/lists/list_class_spec.rb
+++ b/spec/lists/list_class_spec.rb
@@ -34,12 +34,22 @@
   
   
   describe "emit! method (a convenience for developers)" do
-    it "should delete and return the rightmost item responding to the arg message" do
+    it "should delete and return the rightmost item responding to the arg message, if arg is a string" do
       will_work = list([int(1),int(2)])
       will_work.emit!("inc").inspect.should == "2"
       will_work.inspect.should == "(1)"
     end
     
+    
+    it "should delete and return the rightmost item of a given class, if arg is a class" do
+      will_work = list([int(1),int(2)])
+      will_work.emit!(Int).inspect.should == "2"
+      will_work.inspect.should == "(1)"
+      will_work.emit!(Number).inspect.should == "1"
+      will_work.inspect.should == "()"
+    end
+    
+    
     it "should work with empty lists" do
       wont_work = list()
       wont_work.emit!("inc").should == nil
diff --git a/spec/lists/messages/each_message_spec.rb b/spec/lists/messages/each_message_spec.rb
new file mode 100644
index 0000000..2086240
--- /dev/null
+++ b/spec/lists/messages/each_message_spec.rb
@@ -0,0 +1,36 @@
+#encoding: utf-8
+require_relative '../../spec_helper'
+
+describe "List" do
+  describe "the :each message" do
+    it "should be something a List recognizes" do
+      List.recognized_messages.should include(:each)
+    end
+
+    it "should produce a running Iterator" do
+      enum = list([int(1), int(2)]).each
+      enum.should be_a_kind_of(Array)
+      enum[0].should be_a_kind_of(Iterator)
+    end
+    
+    it "should be running over the number of elements in the original List" do
+      enum = list([int(1), int(2)]).each[0]
+      enum.start.should == 0
+      enum.end.should == 2
+      enum.inc.should == 1
+      enum.response.should == :element
+    end
+
+    it "should produce the expected output" do
+      letters = ('a'..'f').collect {|i| message(i)}
+      interpreter(script:"each", contents:[list(letters)]).run.inspect.should ==
+        "[:a, :b, :c, :d, :e, :f, (0..6..6)=>[:a, :b, :c, :d, :e, :f] :: :: «»]"
+    end
+
+    it "should not respond to changes to the contents length" do
+      letters = ('a'..'f').collect {|i| message(i)}
+      interpreter(script:"each copy", contents:[list(letters)]).run.inspect.should ==
+        "[:a, :b, :c, :d, :e, :f, (0..6..6)=>[:a, :b, :c, :d, :e, :f, :f] :: :: «»]"
+    end
+  end
+end
diff --git a/spec/lists/messages/fold_down_message_spec.rb b/spec/lists/messages/fold_down_message_spec.rb
index 14c0baa..d504b9b 100644
--- a/spec/lists/messages/fold_down_message_spec.rb
+++ b/spec/lists/messages/fold_down_message_spec.rb
@@ -43,5 +43,11 @@
       interpreter(contents:[cause_havoc], script:"fold_down").run.inspect.should == "[:: :: «»]"
     end
     
+    it "should work when an intermediate result is an Array that has a nil in it" do
+      bad_boy31 = interpreter(buffer:[message(:fold_down)],
+        contents:[list([message(:fold_down),Binder.new([Iterator.new]), message(:fold_down)])]).run
+      bad_boy31.inspect.should == "[{(0..0..0)=>[]} :: :: «»]"
+    end
+    
   end
 end
\ No newline at end of file
diff --git a/spec/lists/messages/fold_up_message_spec.rb b/spec/lists/messages/fold_up_message_spec.rb
index b03f047..8184cf3 100644
--- a/spec/lists/messages/fold_up_message_spec.rb
+++ b/spec/lists/messages/fold_up_message_spec.rb
@@ -42,5 +42,12 @@
       interpreter(contents:[cause_havoc], script:"fold_up").run.inspect.should == "[4 :: :: «»]"
     end
     
+    it "should work when an intermediate result is an Array that has a nil in it" do
+      bad_boy31 = interpreter(buffer:[message(:fold_up)],
+        contents:[list([message(:fold_up),Binder.new([Iterator.new]), message(:fold_up)])]).run
+      bad_boy31.inspect.should == "[{(0..0..0)=>[]} :: :: «»]"
+    end
+    
+    
   end
 end
diff --git a/spec/lists/messages/infold_down_message_spec.rb b/spec/lists/messages/infold_down_message_spec.rb
index d8b19ea..1d98290 100644
--- a/spec/lists/messages/infold_down_message_spec.rb
+++ b/spec/lists/messages/infold_down_message_spec.rb
@@ -43,6 +43,5 @@
       interpreter(contents:[cause_havoc]).inspect.should == "[(:zap, :foo, 4) :: :: «»]"
       interpreter(contents:[cause_havoc], script:"infold_down").run.inspect.should == "[:: :: «»]"
     end
-    
   end
 end
\ No newline at end of file
diff --git a/spec/locals/messages/bind_message_spec.rb b/spec/locals/messages/bind_message_spec.rb
index 4323ccc..5705d3f 100644
--- a/spec/locals/messages/bind_message_spec.rb
+++ b/spec/locals/messages/bind_message_spec.rb
@@ -22,7 +22,7 @@
     it "should be able to bind even another Local" do
       d = Interpreter.new script:"_foo bind _bar _baz bind _baz bind _foo"
       d.run
-      d.contents.inspect.should == "[:_baz=:_foo=:_bar, :_bar=:_foo=:_bar]"
+      d.inspect.should ==  "[:_baz=:_foo=:_bar, :_bar=:_foo=:_bar :: :: «»]"
       # no, really, it totally should be that
     end
     
diff --git a/spec/locals/messages/rand_message_spec.rb b/spec/locals/messages/rand_message_spec.rb
new file mode 100644
index 0000000..06be840
--- /dev/null
+++ b/spec/locals/messages/rand_message_spec.rb
@@ -0,0 +1,22 @@
+#encoding: utf-8
+require_relative '../../spec_helper'
+
+describe "Local" do
+  describe "rand" do
+    it "should be recognized by Local items" do
+      Local.recognized_messages.should include :rand
+    end
+    
+    it "should return a Local" do
+      Local.new("_gg").rand.should be_a_kind_of(Local)
+    end
+    
+    it "should random Local of lowercase letters (with underscore) the same length as it is" do
+      one = Local.new("_f")
+      one.rand.value.should match /_[a-z]/
+      three = Local.new("_aaa")
+      three.rand.value.length.should == 4
+      three.rand.value.should match /_[a-z]{3}/
+    end
+  end
+end
diff --git a/spec/messages/messages/eql_message_spec.rb b/spec/messages/messages/eql_message_spec.rb
index 10f136f..6a90cd4 100644
--- a/spec/messages/messages/eql_message_spec.rb
+++ b/spec/messages/messages/eql_message_spec.rb
@@ -2,6 +2,10 @@
 
 describe "Message" do
   describe ":eql" do
+    it "should be recognized by Message items" do
+      Message.recognized_messages.should include("eql".intern)
+    end
+    
     it "should create a Closure looking for a second Message" do
       m = message("foo").eql
       m.should be_a_kind_of(Closure)
diff --git a/spec/miscellany/MISC_bug_spec.rb b/spec/miscellany/MISC_bug_spec.rb
index 1047094..a71f05a 100644
--- a/spec/miscellany/MISC_bug_spec.rb
+++ b/spec/miscellany/MISC_bug_spec.rb
@@ -16,5 +16,12 @@
     binder:{x:int(3)})
     lambda { bad_boy.run }.should_not raise_error
   end
+  
+  it "should be able to manage :fold_down sent to Bad Boy 31" do
+    bad_boy31 = interpreter(buffer:[message(:fold_down)],
+      contents:[list([message(:fold_down),Binder.new([Iterator.new]), message(:fold_down)])]).run
+    bad_boy31.inspect.should == "[{(0..0..0)=>[]} :: :: «»]"
+  end
+  
 end
 
diff --git a/spec/numbers/messages/to_script_message_spec.rb b/spec/numbers/messages/to_script_message_spec.rb
new file mode 100644
index 0000000..25c89f5
--- /dev/null
+++ b/spec/numbers/messages/to_script_message_spec.rb
@@ -0,0 +1,15 @@
+#encoding: utf-8
+require_relative '../../spec_helper'
+
+describe "Number" do
+  describe ":to_script message" do
+    it "should return a Script item" do
+      decimal(12.34).to_script.should be_a_kind_of(Script)
+    end
+    
+    it "should contain the value as text" do
+      int(111).to_script.value.should == "111"
+      decimal(12.34).to_script.value.should == "12.34"
+    end
+  end
+end
diff --git a/spec/proxies/messages/^greedy_message_spec.rb b/spec/proxies/messages/^greedy_message_spec.rb
new file mode 100644
index 0000000..9e367e9
--- /dev/null
+++ b/spec/proxies/messages/^greedy_message_spec.rb
@@ -0,0 +1,23 @@
+#encoding:utf-8
+require_relative '../../spec_helper'
+
+describe "Proxy" do
+  describe ":^greedy=" do
+    it "should be recognized by an Interpreter item" do
+      Proxy.recognized_messages.should include("^greedy=".intern)
+    end
+    
+    it "should produce a Closure looking for a Bool" do
+      i = interpreter(script:"^greedy=").run
+      i.contents[0].should be_a_kind_of(Closure)
+      i.contents[0].needs.should == ["¬"]
+    end
+    
+    it "should change the Interpreter greedy_flag" do
+      i = interpreter(script:"^greedy= F")
+      i.greedy_flag.should == true
+      i.run
+      i.greedy_flag.should == false
+    end
+  end
+end
diff --git a/spec/proxies/messages/^quote_message_spec.rb b/spec/proxies/messages/^quote_message_spec.rb
index 894ad5d..ad17536 100644
--- a/spec/proxies/messages/^quote_message_spec.rb
+++ b/spec/proxies/messages/^quote_message_spec.rb
@@ -30,7 +30,7 @@
     end
     
     it "should work when the integer is bigger than the script length" do
-      quoted = interpreter(script:"124 ^quote a b c d e f g h").run
+      quoted = interpreter(script:"444444 ^quote a b c d e f g h").run
       quoted.inspect.should == "[«a b c d e f g h» :: :: «»]"
     end
   end
diff --git a/spec/proxies/messages/^script_message_spec.rb b/spec/proxies/messages/^script_message_spec.rb
index d9c491c..a9cab8e 100644
--- a/spec/proxies/messages/^script_message_spec.rb
+++ b/spec/proxies/messages/^script_message_spec.rb
@@ -3,7 +3,7 @@
 
 describe "Proxy" do
   describe ":^script" do
-    it "should be recognized by a Script item" do
+    it "should be recognized by an Interpreter item" do
       Proxy.recognized_messages.should include("^script".intern)
     end
     
diff --git a/spec/proxies/messages/^ticks_message_spec.rb b/spec/proxies/messages/^ticks_message_spec.rb
new file mode 100644
index 0000000..a22e0c3
--- /dev/null
+++ b/spec/proxies/messages/^ticks_message_spec.rb
@@ -0,0 +1,16 @@
+#encoding:utf-8
+require_relative '../../spec_helper'
+
+describe "Proxy" do
+  describe ":^ticks" do
+    it "should be recognized by an Interpreter item" do
+      Proxy.recognized_messages.should include("^ticks".intern)
+    end
+    
+    it "should produce the current tick count of the Interpreter in which it appears" do
+      i = interpreter(script:"foo bar baz ^ticks")
+      i.run
+      i.inspect.should ==  "[:foo, :bar, :baz, 4 :: :: «»]"
+    end
+  end
+end