FWIW, much of the verbosity in this post is optional, e.g. the very first example could be

  static mut base: uint = 0x200000;
  pub extern "C" fn malloc(len: uint) -> *mut u8 {
      base as *mut u8
  }

(I'll admit the second can be reduced less, since it's actually doing real work: basically just dropping the `: uint` on the `let ret`, dropping the `return` and associated `;`, and removing the () on the if condition.)

I guess the major source of verbosity is the `extern "C"`, which, fortunately, is only necessary when one requires a function uses the C ABI/calling-convention; in the overwhelmingly common case one writes `pub fn foo(...)` which will use the Rust ABI (and it gets reduced to just `fn foo(...)` if the function can be private to a module).

That verboseness allows you as a programmer to get the compiler to do exactly what you want, safely. I'm not really a fan of the syntax, but I totally get why it is the way it is; it's hard to do that while keeping the ALGOL/C styled syntax. Nimrod is another way of tackling it, with a Pascal/python influenced way of attacking the problem. It can also be a bit verbose, but trades that off for not having some features that Rust does.

Tl;dr - it's worth it, IMO :)

Interfacing with C is more verbose than typical Rust code. The author of this post also chose not to make use of Rust's type inference, which means that what is typically written as:

  let ret = base;

...was instead written as:

  let ret: uint = base;

...with all the additional verbosity that entails.