Re: questions... about Proc,lambda,block

Hi,

I've noticed I haven't explained well about the Proc orphan.

"break" and "return" will cause LocalJumpError, when they are called
after their corresponding destination is passed.  For "break", the
destination is the block attached method invocation; for "return", it
is the method surrounding the block attached invocation.

Examples (some of them do not work right now as I explain in 1.8/1.9; I'm fixing them):

  Proc.new {
    break
  }.call        # LocalJumpError

# in above example, break is executed from "call", which is invoked
# after Proc.new is finished.

  def meth1(&block)
    block.call
  end
  meth1{break}  # fine

# this one is OK, because "call" is called before meth1 is finished.

  def meth2
    Proc.new{
      return
    }.call
  end           # fine

# this is OK, because at the point of "call", the destination (end of
# meth2) still exists.

  def meth3(&block)
    block
  end
  b=meth3{break}
  b.call        # LocalJumpError


# break is executed after meth3 finished.

  def meth4
    b = meth3{return}
    b.call
  end           # fine

# this is OK.  why?  because meth4 is still working.

  def meth5
    meth3{return}
  end 
  meth5.call    # LocalJumpError

# return from meth5 cannot be done after meth5 is finished.

  lambda{break}  # fine, no break will pass lambda
  lambda{return} # fine, no return will pass lambda

I should have organized things earlier, but I think (and I hope) this
is the final design decision about break and return from Procs, unless
someone prove me I'm wrong.

							matz.