New for loops in Rust

Post by nikomatsakis » Fri, Apr 06, 2012, 5:07 PM UTC

vilya wrote: post #16

This looks like a bad design. It means either (a) the semantics of 'ret' inside a lambda function can change depending on the call site (whether it's used inside a for loop or not); (b) that a lambda function passed in from elsewhere can cause your function to return early; or (c) that lambda functions have different syntax rules depending on where they're being defined. All of which seem equally bad! I hope there's…

Post by nikomatsakis » Fri, Apr 06, 2012, 8:58 PM UTC

chubot wrote: post #6

I'm going to make a superficial comment and say that "cont" and "ret" are annoying and gratuitous differences. C/C++, Java, Python, JavaScript, and I think Perl/Ruby/Go all use "continue" and "break". It's just pointless to be different in this respect. A different concept should use different syntax -- and it looks like Rust has several new concepts where they can invent whatever syntax they want. But the same conce…

Post by vilya » Sat, Apr 07, 2012, 1:02 PM UTC

nikomatsakis wrote: post #20

vilya wrote: post #16

This looks like a bad design. It means either (a) the semantics of 'ret' inside a lambda function can change depending on the call site (whether it's used inside a for loop or not); (b) that a lambda function passed in from elsewhere can cause your function to return early; or (c) that lambda functions have different syntax rules depending on where they're being defined. All of which seem equally bad! I hope there's…

You're missing something. The semantics of `ret` are always consistent: it always returns from out the innermost `fn()` declaration (closures written using the sugared notation `{||...}` do not count as fn declarations, but closures written as `fn() { ... }` do). In cases where this is not possible, a static error is generated.

  fn foo(f: fn()) {
    log(info, "calling f");
    f();
    log(info, "called f");
  }

  fn bar() {
    log(info, "calling foo");
    foo({||
      ret;
    });
    log(info, "called foo");
  }

Post by kibwen » Tue, Apr 10, 2012, 4:24 PM UTC

vilya wrote: post #25

nikomatsakis wrote: post #20

Earlier quoted context omitted.

You're missing something. The semantics of `ret` are always consistent: it always returns from out the innermost `fn()` declaration (closures written using the sugared notation `{||...}` do not count as fn declarations, but closures written as `fn() { ... }` do). In cases where this is not possible, a static error is generated.

So what happens if we pass a stack closure containing a ret into another function? For example, what would this code print out: fn foo(f: fn()) { log(info, "calling f"); f(); log(info, "called f"); } fn bar() { log(info, "calling foo"); foo({|| ret; }); log(info, "called foo"); } I'm not clear on whether the ret would return from foo or from bar - or whether it would be a compile error. BTW thanks for taking the time…

  `ret` in block function