"mismatched types expected unit type `()` found enum `Option<String>`" Error when trying to read the content of a file with Tauri

It looks like tauri has changed its API in this area. See https://docs.rs/tauri-api/0.7.6/tauri_api/dialog/index.html. Now the functions no longer accept a closure, but instead return a dialog::Response struct.

This means your code could be written as something like:

// This is tauri's internal error type too.
use anyhow::{Error, bail};

fn open_file_impl() -> Result<String, Error> {
    use tauri::api::dialog::Response;
    let result = tauri::api::dialog::select(None,None)?;
    
    let path = match {
        Response::Okay(s) => s;
        Response::OkayMultiple(s) => bail!("multiple selected"),
        Response::Cancel => bail!("canceled");
    }
    Ok(fs::read_to_string(directory)?)
}

pub fn open_file() -> Option<String> {
   open_file_impl().ok()
}

I'd probably introduce a concrete error type with this, rather than relying on anyhow... but that does make things longer.

Or you could get rid of the open_file_impl altogether...

fn open_file_impl() -> Option<String> {
    use tauri::api::dialog::Response;

    let result = tauri::api::dialog::select(None,None).ok()?;
    if let Response::Okay(path) = result {
        fs::read_to_string(directory).ok()
    } else {
        None
    }
}

Edit

This post does not work for the OP question, because tauri's API requires the closure to be 'static, and thus rules out the possibility (except with dirty unsafe hacks) to retrieve the content of the file in a way similar to what was asked.

Also, tauri's API has been changed in more recent versions. If you are only interested in a solution that specifically works with tauri, please see @Michael Anderson's answer.

As you can see, there are two errors, which are opposite, in some way: one error tells you that Rust expected (), but found Option<String>, and the other one that it expected Option<String>, but found (). This should prompt you to check if you are passing you Option<String> at the right place and, in fact, you're not.

A closure is a function (not quite the same as other functions you define with fn, but still a function), so when you call return in it, you're actually returning inside the closure. So, the error just comes from the fact that pick_file expected a function that returns (), whereas you provided one that returns Option<String>, and conversely the outer function is (implicitly) returning ().

You may ask: is there a way to return from inside the closure, but for the return statement to apply to the outside function, and the answer is no, so one way would be to create a variable outside and mutate it from inside the closure:

fn open_file() -> Option<String> {
    let dialog_open_file = tauri::api::dialog::FileDialogBuilder::new();
    let mut result = None;
    dialog_open_file.pick_file(|path| {
        if let Some(directory) = path {
            let archivo = fs::read_to_string(directory);
            if let Ok(content) = archivo {
                result = Some(content);
            }
        }
    });
    result
}

If you format your code, you would find out that you are missing the return statement in the outer space.

fn open_file() -> Option<String> {
    let dialog_open_file = tauri::api::dialog::FileDialogBuilder::new();
    let mut result = None;
    dialog_open_file.pick_file(|path| match path {
        Some(directory) => {
            let archivo = fs::read_to_string(directory);
            match archivo {
                Ok(content) => result = Some(content),
                Err(error) => result = None,
            }
        }
    });
    result
}