Hacker News Reader

Comment by steveklabnik | Hacker News Reader

Well, you generally don't, because Duff's Device isn't generally regarded as a good idea anymore, in my understanding:

  > It turns out that with branch predictions and the relative speed of CPU
  > vs. memory changing over the past decade, loop unrolling is pretty much
  > pointless.

http://lkml.iu.edu/hypermail/linux/kernel/0008.2/0171.html

View on HN

Still, there are cases where fall-through can be useful:

    int remaining = length % 4;
    switch (remaining) {
        case 3: h ^= (data[(length & ~3) + 2] & 0xff) << 16;
        case 2: h ^= (data[(length & ~3) + 1] & 0xff) << 8;
        case 1: h ^= (data[length & ~3] & 0xff);
                h *= m;
    }

https://github.com/pythonesque/fallthrough can emulate the fallthrough style if you really, really want to have it. It seems like it hasn't been updated in a while, though.

In the post-1.0 world, a repository not having been updated for a few months doesn't automatically mean it no longer works :P

That's true but January 11 is in that weird grey area...

Let me be clearer: that repository works fine and doesn't rely on the standard library at all.

It's interesting, but a loop makes for smaller code, by a couple dozen bytes or so:

    int remaining = len % 4;

    if (remaining)
    {
        do
        {
            remaining--;
            h ^= (data[(length & ~3) + remaining] & 0xff) <<  (remaining * 8);
      } 
      while(remaining);

      h *= m;
    }

Fall-through's interesting, but at the same time, as architectures have changed, has become less useful. Self-modifying code at one time was near vital, but has fallen by the wayside, fall-through is doing much the same.

Usually I would just factor out the guts of the expression into a little closure in that case. (let f = |x| h ^= ... x ...) LLVM should inline it just fine, and it'll save you typing.

If loops can have specialized control-flow keywords (break; continue), why not let match have one (fallthrough)?

    match x {
        0 => { /* do some stuff */; fall_through; },
        1 => true,
        _ => false
    }

However, I don't know yet how useful it would be. I can't remember ever really needing it, so it would probably need a few practical examples before it became a reality but its an idea.

If we really need it I'd rather have C#-style goto-label instead of explicit fall-through, which is strictly less general. (But I'd almost rather it be a tail-duplicating macro to begin with, since the feature is so rarely needed.)

I don't see how this helps here, unless you intend to call the closure several times per case.

I wonder if this is really faster than just writing it as a loop.

Reply on news.ycombinator.com