[#11073] segfault printing instruction sequence for iterator — <noreply@...>

Bugs item #10527, was opened at 2007-05-02 14:42

14 messages 2007/05/02
[#11142] Re: [ ruby-Bugs-10527 ] segfault printing instruction sequence for iterator — Nobuyoshi Nakada <nobu@...> 2007/05/10

Hi,

[#11188] Re: [ ruby-Bugs-10527 ] segfault printing instruction sequence for iterator — Paul Brannan <pbrannan@...> 2007/05/16

On Thu, May 10, 2007 at 04:51:18PM +0900, Nobuyoshi Nakada wrote:

[#11234] Planning to release 1.8.6 errata — Urabe Shyouhei <shyouhei@...>

Hi all.

17 messages 2007/05/25

[ ruby-Bugs-10598 ] return from block inside a lambda does not work as expected

From: <noreply@...>
Date: 2007-05-05 03:00:19 UTC
List: ruby-core #11092
Bugs item #10598, was opened at 2007-05-04 20:00
You can respond by visiting: 
http://rubyforge.org/tracker/?func=detail&atid=1698&aid=10598&group_id=426

Category: Core
Group: 1.8.x
Status: Open
Resolution: None
Priority: 3
Submitted By: Jeff Reinecke (paploo)
Assigned to: Nobody (None)
Summary: return from block inside a lambda does not work as expected

Initial Comment:
As I understand it, a lambda block is different than a Proc.new block in that return works like it does in functions, allowing you to essentially create inline anonymous functions that have access to the variable scope in which it is defined.  (This is great for some complex algorithms).

When trying to use this functionality with a lambda function that, inside of it had several levels of iteration utilizing Range#each, I found that doing a return from within any of the blocks used by Range#each would return the whole top level function, not just the lambda.

This is inconsistent with both what I'd expect, and what return does if it is used anywhere else in a labmda block.


As an example, please consider the following trivial and highly contrived example.  A call to foo returns out of the defined lambda block m, assigning the variable q and returning from foo properly, when v is negative.  However, if v is positive and the iteration over the range is executed, the return returns from both m and foo, skipping the assignment to q and the further processing that foo does to that result, and instead returns n straight out of foo.  (I bet that was hard to follow)  :)


def foo(value)
  m = lambda do |v|
    return "v is negative" if v < 0
      (5...100).each do |n|
        #This line returns from the whole method, not just from the block!
        return n if v.modulo(n).zero?
      end
    return false
  end
  
  q = m.call(value)
  return "ANSWER: #{q.inspect}"
end

----------------------------------------------------------------------

You can respond by visiting: 
http://rubyforge.org/tracker/?func=detail&atid=1698&aid=10598&group_id=426

In This Thread

Prev Next