man!(D => Rust).basics

Это как-то выделяет Rust? А D что, разрешает?

D, по умолчанию, просто инициализирует все переменные:

int val;
writeln(val); // выведем int.init

Rust этого не делает и требует нас самих инициализировать:

let val: i32;
println!("{}", val); // use of possibly uninitialized variable

Согласитесь, что есть разница. Да, в плане "безопасности" она не особо существенна, но подход-то другой.

Ну и если честно, не совсем понял аргумент. Как процитированное относится к знанию языка? Я разве что-то неправильно сказал?

Тогда не очень понятно, что они сэкономили сделав return опциональным. Неконсистентный синтаксис получился

В большинстве случаев early returns не используются. Кроме того, Rust — это expression-based язык, как Scala. Например, вместо тернарного оператора в нём if:

let y = if x > 0 { ... } else { ... };

Отсутствие необходимости писать return для возврата значения, если это значение — последнее выражение в функции, вытекает из этого совершенно естественно.

номинативную, через интерфейсы

Интерфейсы — это всё-таки немного не то. Если я не ошибаюсь, в D, как и в C++ и в Java, интерфейсы подразумевают динамическую диспетчеризацию. В Rust динамическая диспетчеризация используется только если вы сами её попросите (через трейт-объекты).

Вот полностью из песочницы на сайте

Такое сообщение появляется, если в качестве параметра add() используется нетипизированный литерал (42). Для удобства в Rust, как и во многих языках, числовые литералы могут автоматически принимать любой тип. Но в данном контексте он используется в качестве аргумента дженериковой функции, поэтому компилятор не может вывести тип литерала так просто. Вот такая ошибка возникает, если тип литерала указать явно (42i32):

<anon>:9:20: 9:23 error: the trait `core::ops::Add<&str>` is not implemented for the type `i32` [E0277]
<anon>:9     println!("{}", add(42i32, "eee"));
                            ^~~

На мой взгляд, понятнее некуда.

Но в 99% случаев инициализируются они всё равно дефолтными значениями. Наверняка в процессе хитрых кастов можно случайно обойти ограничение на неиспользование неинициированной памяти.

Неинициализированные переменные ничем не инициализируются, если этого не указать явно, и нет, случайно обойти это ограничение нельзя в принципе. Одна из целей Rust — это гарантия полной безопасности работы с памятью; это включает в себя полный запрет на работу с неинициализированной памятью вне unsafe.

изменение типа в зависимости от того, какая функция была вызвана первой

Вообще-то это и есть вывод типов. Компилятор выводит тип переменной в зависимости от того, как она используется. Просто в Rust вывод типов действует внутри функции целиком, а не только при присваивании значения, как с auto в C++.

Редактирование такого кода, как хождение по минному полю. Ну или покажите пример, где оно действительно полезно.

Вам это так кажется. Редактировать и рефакторить такой код ничуть не сложнее, чем код без вывода типов, даже в чём-то проще — меньше печатать нужно. Почти не бывает такого, чтобы при рефакторинге тип переменной внезапно менялся, хотя бы потому, что объявлять отдельностоящие неинициализированные переменные неидиоматично. Кроме того, объявления типов обязательны в сигнатурах функций и констант/статических переменных, даже если они объявляются внутри другой функции.
Пример "действительной полезности" привести сложно — это всё-таки не фича уровня borrow checker'а, без которой невозможно жить, а элементарное удобство. Обойтись без этого можно всегда. Но я вот совершенно не могу придумать несинтетического примера, где это бы помешало. Специально сейчас пять минут посвятил просмотру кода своих библиотек, и не нашёл ни одного проблемного места.

Редактирование такого кода, как хождение по минному полю. Ну или покажите пример, где оно действительно полезно.

Лучше покажите как при помощи этой фичи можно в ногу неожиданно выстрелить. (:

Впрочем, в Rust есть ещё одна "спорная фича":

let a = 10;
let a = a.to_string();
let a = Some(a);

На всякий случай, уточняю: переменная a неизменяемая, просто тут три разных а. Когда впервые увидел, то показалось, что это ужасное решение и источник непонятных ошибок. А на деле оказывается удобно.

Тогда не очень понятно, что они сэкономили сделав return опциональным.

Короткие функции выглядят гораздо приятнее. return в 1-2-строчных функциях меня очень раздражает. А в C++ до недавнего времени константные функции могли быть только однострочными.
Кроме того, в Rust принято использовать return для нештатного завершения, обычно при ошибке. Так как исключения не поддерживаются, такая двойственность синтаксиса делает код более читабельным.

Потому что, когда цепочки пишешь приходится в дополнительные скобки брать.

Да, про это не подумал.

У Вас каждый man! новый хэшмап создает и заполняет каждый раз.
enum Lang {
Go,
D,
Rust,
}
use Lang::*;

struct Info {
basics: &'static str,
concurrency: &'static str,
}

macro_rules! man {
($lang1:ident => $lang2:ident) => {{
match ($lang1, $lang2) {
(Go, D) => Info {
basics: «habrahabr.ru/post/279657»,
concurrency: «habrahabr.ru/post/280378»,
},
(D, Rust) => Info {
basics: «habrahabr.ru/post/280642»,
concurrency: «TODO: DarkEld3r еще не написал»,
},
_ => unreachable!()
}
}}
}

fn main() {
println!(«Go => D basics: {}», man!(Go => D).basics);
println!(«Go => D concurrency: {}», man!(Go => D).concurrency);
println!(«D => Rust basics: {}», man!(D => Rust).basics);
println!(«D => Rust concurrency: {}», man!(D => Rust).concurrency);
}

Аналог на D:

import std.traits;

alias Lang = int;

enum : int {
    Go ,
    D ,
    Rust ,
};

struct Info {
    string basics;
    string concurrency;
}

enum articles = [
    [ Go , D ] : Info( "https://habrahabr.ru/post/279657" , "https://habrahabr.ru/post/280378" ) ,
    [ D , Rust ] : Info( "https://habrahabr.ru/post/280642" , "TODO: DarkEld3r еще не написал, скорее бы" ) ,
];

template man( Lang function( Lang ) axis )
{
    static if( is( FunctionTypeOf!axis args == __parameters ) )
    {
        enum from = mixin( __traits( identifier , args ) );
        enum to = axis( from );
        enum man = articles[[ from , to ]];
    }
}

unittest {
    static assert( man!(Go => D).basics == "https://habrahabr.ru/post/279657" );
    static assert( man!(Go => D).concurrency == "https://habrahabr.ru/post/280378" );
    static assert( man!(D => Rust).basics == "https://habrahabr.ru/post/280642" );
    static assert( man!(D => Rust).concurrency == "TODO: DarkEld3r еще не написал, скорее бы" );
    static assert( !is( man!(Go => Rust).concurrency ) );
}

void main( ) { }

Дык, если нам надо, то будем использовать типы фиксированного размера. В Go int — это аналог ptrdiff_t, а не int из D.

Да, panic — это макрос, который раскрывается в вызов как раз такой специальной функции:

fn begin_unwind<M: Any + Send>(msg: M, file_line: &(&'static str, u32)) -> ! { ... }

Для наглядности мой пример можно и переписать заменив панику на собственную функцию:

fn my_panic() -> ! {
    loop {}
}

fn fake_panic() {}

fn main() {
    let _a: String = match 10 {
        10 => "normal value".to_owned(),
        //_ => fake_panic(), // Error.
        _ => my_panic(),
    };
}