Return empty String if match fails in function

An idiomatic way to solve your issue would be to refactor slightly your code: because code in get_html could fail, it's natural that its signature reflects this, so instead of returning a String, it could return an Option<String>, leaving the caller decide on what to do in this case:

fn get_html(address: &str) -> Option<String> {
    reqwest::blocking::get(address)
        .ok()?
        .text()
        .ok()
}

See the playground. This makes the code much more straightforward. However, you may really want the signature of the function to be -> String, not -> Option<String>. In this case, there are two solutions.

The first solution would be to use the experimental try block. I mention this solution, not because it's currently the most adequate, but because it will be one day (most likely).

fn get_html(address: &str) -> String {
    let result: Option<_> = try {
        reqwest::blocking::get(address)
            .ok()?
            .text()
            .ok()?
     };
     result.unwrap_or_default()
}

See the playground.

Note that, as is, Rust is not able to figure out types on its own for the try block, so we have to help it, which makes this more verbose. This aspect will probably improve over time, when try blocks are stabilized.

Also note that, since the Default::default constructor of String produces an empty string, we can directly use .unwrap_or_default() instead of .unwrap_or(String::new()) or .unwrap_or_else(|| String::new()) (since an empty string is not allocated, the first option is also acceptable).

The second solution would simply be to add an other function with the wanted signature, and make it use the first function

fn get_html_failable(address: &str) -> Option<String> {
    reqwest::blocking::get(address)
        .ok()?
        .text()
        .ok()
}

fn get_html(address: &str) -> String {
    get_html_failable(address).unwrap_or_default()
}

This may seem unconvenient, but lots of libraries in Rust have internal error propagation using types that represent failure (such as Result or Option), because it's really convenient to write such functions and to compose them (both reqwest::blocking::get and .text() return a Result, and see how easy it is to use them in a function that returns an Option), and have wrapper function that expose the wanted signature (most libraries will still expose fail types, but if you are writing an application it's not necessarily the best choice).

A variable of both preceding workarounds is to "simulate" a try block in stable Rust, without relying on an additional toplevel function.

fn get_html(address: &str) -> String {
    (|| reqwest::blocking::get(address).ok()?.text().ok())()
        .unwrap_or_default()
}

See the playground. Note that, in this case, countrary to the try version, Rust is able to figure out the right types on its own.

This is probably the least readable solution, so I wouldn't recommend it (use try blocks instead). But it works.