Rust и парадокс Блаба

Но на практика довольно редко приходится использовать типаж-объекты.

Если вы говорите про подход с обработкой ошибок с помощью Result, то накладные расходы здесь гораздо меньше, чем у исключений. Фактически, накладной расход — это дополнительное поле-дискриминатор enum'а в возвращаемом значении, и всё.

В Rust невозможно проигнорировать ошибку а-ля catch (Exception e) в Java. Если функция, которую вы вызываете, может завершиться с ошибкой, то её возвращаемое значение будет типа Result<T, Error>, из которого собственно T можно достать только явно, через паттернматчинг

use std::io;
use std::fs::File;
use std::io::prelude::*;

fn write_to_file_errors_ignored() {
    let _ = || -> Result<(), io::Error> {
        let mut file = try!(File::create("my_best_friends.txt"));
        try!(file.write_all(b"This is a list of my best friends."));
        println!("I wrote to the file");
        Ok(())
    }();
}

fn main() {
    write_to_file_errors_ignored();
}

void writeToFileIgnoreExceptions() {
    try {
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("filename.txt"), "utf-8"));
        writer.write("This is a list of my best friends.");
        System.out.println("I wrote to the file");
    } catch (IOException ex) {}
}

«Хорошее решение» демонстрирует код таким, каким он должен быть, если бы он изначально писался на С++, и писался хорошо.

Это сработает только для очень простых примеров, для любой сложной реализации типажей у вас не получится провернуть подобный трюк.

Первое, что приходит в голову – отсутствие типов-сумм

#include <boost/variant.hpp>
#include <iostream>
#include <utility>

template <class T, class E>
class Result {
public:
    template <class U>
    Result( U&& obj )
      : value( std::forward<U>( obj ) )
    {
    }

    T unwrap() &&
    {
        assert( value.which() == 0 );
        return std::move( boost::get<T>( value ) );
    }

    template <class F>
    Result or_else( F f ) &&
    {
        if ( value.which() == 0 ) {
            return std::move( boost::get<T>( value ) );
        }
        else {
            return f();
        }
    }

private:
    boost::variant<T, E> value;
};

class File {
public:
    static Result<File, bool> open( const std::string& s )
    {
        if ( s == "exist" ) {
            return File{};
        }
        else {
            return false;
        }
    };
};

int main()
{
    auto file = File::open( "unexist" ).or_else( [] { return File::open( "exist" ); } ).unwrap();
}

Третее – не уверен, что в С++ получится c такой же легкостью передавать в комбинаторы замыкания, которые в результате будут заинлайнены и не будут создавать каких-либо накладных расходов