Breakpoint

A word on UFCS

I talked about UFCS but didn't explain what it was on the spot not to cut the flow of the code too much. It is a very easy concept; it just states that the first argument of a function can be moved before it using a dot.

The following calls are all perfectly equivalent (and useless):

writeln(toLower("TEST"), ".txt");
toLower("TEST").writeln(".txt");
"TEST".toLower().writeln(".txt");

To that we must add that empty parentheses are always optional, so we can also write:

"TEST".toLower.writeln(".txt");

This serves two purposes.

First of all it looks nice: it gives a feeling of pipeline programming that fits well processes such as our crc32 function where the code flows from one function into another.

Secondly it allows making weak overloads of methods. Let's say you have a lot of classes and would like to add a method to manage a given type but don't want to write an overload for each class. One way is to write a function that manages that type and can take any of the classes we want and use UFCS to make it look like a method call.

There are of course limits to that approach so it's not what I'd recommend in that situation, but it can definitely come in handy sometimes.

Managing arguments

Side note but I like getopt in D.

There are different ways to define lambda functions in D. One way is (x => x*2;). This is equivalent to: (auto x) { return x*2; }. But what if the function takes no argument? Then you get empty parentheses. And empty parentheses are optional. So below, half the arguments are actually lambda functions. Those can be hard to spot at first admitedly, so prefer the other forms.

…   getopt(args,
        "recursive|r", { spanmode = SpanMode.depth; },
        "version|v",   { writeln("crc32 v", vernum); exit(0); },
        "help|h",      { write(help); exit(0); },
    );

The langage has what's called "slices". It is what we call "a range" in python: for example here args[1..$] is equivalent to the python args[1:]. One interesting thing is that they do not copy data, it's simply a pointer's game. They are therefore very interesting when making parsers etc.

…   // Without arguments, use stdin
    if (args[1..$].length == 0) {
        writeln(stdin.crc32);
        return 0;
    }

Templates

Our first use of a template. isFile is a function that takes a file and returns a boolean. Filter is a template (as are most things that we manipulate here actually, but it's the first one that we will use as a template). It takes as first compile-time argument a lambda or function and as first runtime argument a range (D's concept of iteration, similar to generators in Python).

Here the call could have been written:

filter!(isFile)(args[1..$])

The first set of parens is prefixed with ! so it's a compile-time argument. The second set is the runtime argument. In C++ it would have been filter<isFile>(args[1..$]). Remember UFCS? We can rewrite it (dropping the empty parens):

args[1..$].filter!(isFile)

And as the call is unambiguous we can drop the last parens as well.

Filter returns a range, it is lazy as many things in the standard library, and as we want to reuse it we will turn it into an array which is the last call of the section (equivalent to list() in python. This array is GC-allocated, we could have filled a malloced-buffer though.

…   // Make list of inputs
    string[] fileList = args[1..$].filter!isFile.array;

Ok, now that the basics are understood, we do the same thing but bigger, and with more functions!

We introduce map that also takes a function or lambda as compile-time argument. Here we pass a lambda. The call is similar to python-ish map(lambda d: dirEntries(d, spanmode), ...).

each is another interesting template. It's just a foreach actually, it doesn't bring anything, it exists solely because it fits well with UFCS. The body of the foreach is passed as a lambda which uses more of what we saw.

There is a last subtlety though: the ~= operator. It's like += in python, but D decided to separate addition (+) and concatenation (~).

…   // Add inputs from directory arguments
    args[1..$].filter!isDir
              .map!(d => dirEntries(d, spanmode))
              .each!((dir) => fileList ~= dir.map!(e => e.name)
                                             .filter!isFile
                                             .array);

Not much to say next...

…   // Remove duplicates
    sort(fileList);
    fileList = fileList.uniq.array;

A real foreach. We didn't specify the type of f so it's infered.

…   foreach (f ; fileList) {
        File file;

This is interesting. We don't have context managers like python. However we have scope managers. The following line ensures that when quitting the scope defined by the enclosing {} we will close the file.

There are also scope(success) and scope(error), and they can be used multiple times in a same scope: they just stack nicely at the end.

…       scope(exit) file.close;

Exceptions, very classic. One note though: D has two kinds of Throwables: Exceptions and Errors. The former are meant to be caught, the later signal an unrecoverable error. They are not to be caught. This distinction doesn't mean much but shows well the fact that D is meant to build programs that work correctly.

…       try {
            file = File(f, "rb");
        } catch(FileException ex) {
            stderr.write(ex.msg);
            continue;
        }

This first line is actually a function call, optionnal parens etc... I like optional parentheses, maybe to the point of abuse. I don't know. It's my style and not D's recommended style though, so if you don't like it just write it differently.

        auto crc = file.crc32;
        if (crc)
            writefln("%s\t%s", crc, f);
    }

    return 0;
}

Image source

• Unknown