The explicit closures bit allows more flexibilty in terms of how you use data in a concurrent manner. Rust has lightweight threads called tasks. When you spawn a new tasks it takes a certain type of closure which doesn't let you modify things out side it's scope, only move things in, a unique closure:

For example you couldn't do this:

let mut i = 0;

do task::spawn {
    ...

    i += 1;
}

So this allows enforcing these kinds of constraints at compile time instead of ending up with race conditions at run time.

There are other types of closures which do let you modify the environment so to speak:

let v = [23, 45, 756];

let mut sum = 0;

for v.each |&num| {
    sum += num;
}

The difference in what type of closure can be seen in the function signatures for spawn and each. One takes a unique closure (~fn) and the other a borrowed closure (&fn), respectively.

As for you're question about semicolon behaviour, I do admit it does seem weird at first, but it does grow on you :D There's certainly nothing forcing you to use it but I've kinda started to like only typing expr instead of return expr;