Re: To help LDC/GDC

[bearophile]

To: NG D
Subject: Re: To help LDC/GDC

This D code comes from a Haskell solution by tanakh of the 
Lawnmower problem of the Google Code Jam 2013 Qualification Round:


import std.stdio, std.string, std.conv, std.range, std.algorithm;

void main() {
  immutable n = stdin.readln.strip.to!int;

  foreach (immutable cn; 1 .. n + 1) {
    const hw = stdin.readln.split.to!(int[]);
    const bd = hw[0].iota.map!(i => 
stdin.readln.split.to!(int[])).array;
    const tbd = hw[1].iota.map!(i => 
bd.transversal(i).array).array;

    bool checkH(in int ch) {
      const okX = tbd.map!(xl => xl.all!(x => x <= ch)).array;
      foreach (oky, r; bd.map!(yl => yl.all!(y => y <= 
ch)).zip(bd))
        //foreach (okx, c; tbd.map!(xl => xl.all!(x => x <= 
ch)).zip(r))//Slow.
        foreach (okx, c; okX.zip(r))
          if (c <= ch && !(okx || oky))
            return false;
      return true;
    }

    writefln("Case #%d: %s", cn, iota(1, 101).all!checkH ? "YES" 
: "NO");
  }
}



In the inner foreach I have had to compute okX before the loops 
otherwise the code gets several times slower. Is such 
optimization possible from a D compiler? Both "map" and "all" 
should be pure. The Haskell compiler uses library-defined 
"rewrite rules" to help in such cases.

Bye,
bearophile