use approach B to impl produce

Author: KDr2

src/tapedtask.jl

@@ -35,8 +35,8 @@ function TapedTask(tf::TapedFunction, args...)
         close(consume_ch)
     end
     t = TapedTask(task, tf, produce_ch, consume_ch)
-    # task.storage === nothing && (task.storage = IdDict())
-    # task.storage[:tapedtask] = t
+    task.storage === nothing && (task.storage = IdDict())
+    task.storage[:tapedtask] = t
     tf.owner = t
     return t
 end
@@ -73,7 +73,9 @@ function increase_counter(t::Tape)
 end
 next_step(t::TapedTask) = increase_counter(t.tf.tape)
 
-# A way (the old way) to impl `produce`, which does NOT
+#=
+# ** Approach (A) to implement `produce`:
+# Make`produce` a standalone instturction. This approach does NOT
 # support `produce` in a nested call
 function internal_produce(instr::Instruction, val)
     tape = gettape(instr)
@@ -91,14 +93,17 @@ function (instr::Instruction{typeof(produce)})()
     args = val(instr.input[1])
     internal_produce(instr, args)
 end
+=#
 
-#=
-# Another way to support `produce` in nested call. This way has its caveat:
+# ** Approach (B) to implement `produce`:
+# This way has its caveat:
 # `produce` may deeply hide in an instruction, but not be an instruction
 # itself, and when we copy a task, the newly copied task will resume from
 # the instruction after the one which contains this `produce` call. If the
 # call to `produce` is not the last expression in the instuction, that
 # instruction will not be whole executed in the copied task.
+# With the abilty to trace into nested function call, we can minimize the
+# limitation of this caveat.
 @inline function is_in_tapedtask()
     ct = current_task()
     ct.storage === nothing && return false
@@ -115,7 +120,7 @@ function produce(val)
     take!(ttask.consume_ch) # wait for next consumer
     return nothing
 end
-=#
+
 
 function consume(ttask::TapedTask)
     if istaskstarted(ttask.task)