I didn't agree with this article's definition of "explicit," which feels tautological:

Rust is explicit because you can figure out a lot about your program from the source of it.

But as long as the source code conveys the information, it is still explicit in the narrow sense I defined above.

But if the thing will happen deterministically in a manner that can be derived from the source, it is still explicit in the narrow sense that I laid out earlier.

Source code conveys everything possible about your program in any language.

The best notion of "explicit" is captured by the critique of "local." Here's some nice ways in which Rust is more "local" than C++:

1. Macros require bang!s instead of C++ surprise-insides

2. References require &s and `mut &`s instead of C++ implicit references.

3. Int -> FP conversions require a typecast

In every case, both Rust and C++ allow you to discover the runtime behavior by reading the source code. But I would argue that Rust is more explicit than C++ in every case, wouldn't you agree?

A feature of Rust that is not implicit, but also not local, is method resolution

Isn't method resolution intimately tied to Deref coercion, which allows a type to implicitly (Rust's language) implement methods of another type? So method resolution seems like one of the more implicit features within Rust.

but all of it is explicit if you look at the impl blocks for Vec<T>.

Well, all of Ruby's monkey-patching is explicit in the sense that you can find it if you know where to look.

It's a good effort to refine the meaning but "local" IMO is the best one!