Do I really need mutexes to do any mutation despite not using threads at all?

[hbina]

my main.rs,

pub fn main() {
    let mongodb_url = std::sync::Arc::new(std::sync::Mutex::new(String::default()));
    let app = App::new();
    app.on_mongodb_url_edited({
        let mongodb_url = mongodb_url.clone();
        move |text| {
            println!("edited:{}", text);
            let mut mongodb_url = mongodb_url.lock().unwrap();
            *mongodb_url = text.to_string();
        }
    });
    app.on_mongodb_url_clicked({
        let mongodb_url = mongodb_url.clone();
        move || {
            let mongodb_url = mongodb_url.lock().unwrap();
            println!("clicked:{}", mongodb_url);
        }
    });
    app.run();
}

my .60 file,

App := Window {
    preferred-width: 500px;
    preferred-height: 600px;
    title: "Pinky Pie";
    callback mongodb-url-edited(string);
    callback mongodb-url-clicked();

    VerticalBox {
        HorizontalBox { 
            GroupBox {
                title: "MongoDB URL";
                height: 100px;
                LineEdit {
                    placeholder-text: "Enter some text";
                    edited(text) => {
                        mongodb-url-edited(text);
                    }
                }

                Button {
                    text : "Connect";
                    clicked() => {
                        mongodb-url-clicked();
                    }
                }
            }
        }
    }
}

Does this mean that I need a lock for all the interactions between the UI and the application logic?

Also, because the application is running inside .run() method, this means that my application should consist of a bunch of functions/lambdas that I pass to the callbacks. Am I right?

[ogoffart]

I'm not sure I understand the question, but our code looks correct, yes.
If you want to share mongodb_url to another thread, it needs to be in a Arc<Mutex<...>>

Does this mean that I need a lock for all the interactions between the UI and the application logic?

Sort of, yes.
The UI is in the main thread, and all your callback and functions are going to be run in that thread.
If your logic is in a Arc<Mutex<..>> you indeed need to lock it.

[hbina]

Nope, I think you understood it. Does that mean that all internal sixtyfps structs like VecModel and SharedString all Sync?

[ogoffart]

Not at all. ShareString is Send so it can be send to the logic thread. But VecModel is not even Send and can only be handled from the main thread. (the main thread is the UI thread.)

[hbina]

Does this look like a reasonable code? I haven't even handled many edge cases yet (like selecting a different element in the first combobox does not update the second combobox).
It's probably going to make a lot crazier once I cover all the edge cases and handling errors (how do you handle errors?)

My verbose style aside, I think most of the complexity comes from the fact that I need to maintain 2 identical information at every step: the data in Rust and the data in UI.

pub fn main() {
    let mongodb_url_text = std::sync::Arc::new(std::sync::Mutex::new(
        "mongodb://localhost:27017".to_string(),
    ));
    let mongodb_client = std::sync::Arc::new(std::sync::Mutex::new(None));
    let mongodb_databases = std::sync::Arc::new(std::sync::Mutex::new(vec![]));
    let mongodb_collections = std::sync::Arc::new(std::sync::Mutex::new(vec![]));

    let app = App::new();
    app.on_mongodb_url_edited({
        let mongodb_url_key = mongodb_url_text.clone();
        move |input| {
            let mut mongodb_url = mongodb_url_key.lock().unwrap();
            *mongodb_url = input.to_string();
        }
    });
    app.on_mongodb_url_clicked({
        let app_weak = app.as_weak();
        let mongodb_url_key = mongodb_url_text.clone();
        let mongodb_client_key = mongodb_client.clone();
        let mongodb_databases_key = mongodb_databases.clone();
        move || {
            let mongodb_url = {
                let mongodb_url = mongodb_url_key.lock().unwrap();
                mongodb_url.clone()
            };
            if let Ok(client) = mongodb::sync::Client::with_uri_str(&mongodb_url) {
                println!("Connected to {}", mongodb_url);
                let databases = client.list_database_names(None, None).unwrap();
                {
                    let app = app_weak.unwrap();
                    app.set_mongodb_url_input_enabled(false);

                    app.set_mongodb_databases(sixtyfps::ModelHandle::new(std::rc::Rc::new(
                        sixtyfps::VecModel::from(
                            databases
                                .iter()
                                .map(|s| SharedString::from(s))
                                .collect::<Vec<_>>(),
                        ),
                    )));
                    app.set_mongodb_database_combobox_enabled(true);
                }
                {
                    let mut mongodb_client = mongodb_client_key.lock().unwrap();
                    *mongodb_client = Some(client);
                }
                {
                    let mut mongodb_databases = mongodb_databases_key.lock().unwrap();
                    *mongodb_databases = databases;
                }
            } else {
                eprintln!("Cannot connect to {}", mongodb_url);
            };
        }
    });
    app.on_mongodb_database_clicked({
        let app_weak = app.as_weak();
        let mongodb_client_key = mongodb_client.clone();
        let mongodb_databases_key = mongodb_databases.clone();
        let mongodb_collections_key = mongodb_collections.clone();
        move |input| {
            let mongodb_client = mongodb_client_key.lock().unwrap();
            let mongodb_databases = mongodb_databases_key.lock().unwrap();

            let database = mongodb_databases
                .iter()
                .find(|s| s == &input.as_str())
                .unwrap();
            let collections = mongodb_client
                .as_ref()
                .unwrap()
                .database(database)
                .list_collections(None, None)
                .unwrap()
                .collect::<Result<Vec<_>, _>>()
                .unwrap()
                .iter()
                .map(|v| v.name.to_string())
                .collect::<Vec<_>>();
            {
                let app = app_weak.unwrap();
                app.set_mongodb_collections(sixtyfps::ModelHandle::new(std::rc::Rc::new(
                    sixtyfps::VecModel::from(
                        collections
                            .iter()
                            .map(|s| SharedString::from(s))
                            .collect::<Vec<_>>(),
                    ),
                )));
                app.set_mongodb_collection_combobox_enabled(true);
            }
            {
                let mut mongodb_collections = mongodb_collections_key.lock().unwrap();
                *mongodb_collections = collections;
            }
        }
    });
    app.run();
}

[ogoffart]

Looks alright.

Maybe you can simplify the amount of arc and mutexes by putting everything on the same arc. Like so:

struct MongodbData {
    mongodb_url_text : String,
    mongodb_client: String,
    mongodb_databases : Vec<•••>,
    mongodb_collections : Vec<•••>,
};
let mongodb_data = Arc::new(Mutex::new(MongodbData { ••• }));