External function from Rust not being called

[crides]

Hi, I'm looking to using Gluon in a system I'm developing, where I'm using Gluon to mutate a single stateful object. I created this simple example to test things out:

#[macro_use] extern crate gluon;
use gluon::{new_vm, vm::ExternModule, ThreadExt, base::error::AsDiagnostic, import::add_extern_module};
use gluon_codegen::*;
use lazy_static::lazy_static;
use std::sync::{Arc, Mutex};

#[derive(Clone, Debug, Trace, VmType, Userdata)]
#[gluon_trace(skip)]
#[gluon(vm_type = "test.Counter")]
struct Counter(Arc<Mutex<usize>>);

impl Counter {
    fn new() -> Counter {
        Counter(Arc::new(Mutex::new(0)))
    }
}

lazy_static! {
    static ref COUNTER: Counter = Counter::new();
}

fn main() {
    let vm = new_vm();
    let load_mod = |thread: &gluon::Thread| {
        thread.register_type::<Counter>("test.Counter", &[])?;
        let module = record! {
            type Counter => Counter,
            get_count => primitive!(0, || *COUNTER.0.lock().unwrap()),
            inc_counter => primitive!(0, || {
                let mut counter = COUNTER.0.lock().unwrap();
                println!("before: {}", *counter);
                *counter += 1;
                println!("after: {}", *counter);
            }),
        };
        ExternModule::new(thread, module)
    };
    add_extern_module(&vm, "counter", load_mod);
    vm.run_io(true);
    let res = vm.run_expr::<()>(
        "test",
        r#"
let { get_count, inc_counter, ? } = import! counter
inc_counter
        "#,
    );
    if let Err(e) = res {
        println!("{}", e.as_diagnostic().message);
    }
    dbg!(*COUNTER.0.lock().unwrap());
}

However, the dbg! at the end gave me 0, and the println!s in the middle are not being printed.

I suspected that I'm not calling the function, so I tried inc_counter () (I can only guess, as there's no documentation on how to call a function with no arugments), but I got the following errors:

error: Expected the following types to be equal
Expected: () -> a
Found: ()
1 errors were found during unification:
Types do not match:
    Expected: () -> a
    Found: ()
- <test>:3:13
  |
3 | inc_counter ()
  |             ^^
  |
- Attempted to call a non-function value

I have no idea what this error means, as inc_counter is for sure defined as a function through primitive!.

So is the inc_counter function being optimized out? If so, how can I include the call back? And where can I find the documentation for it, or around which source files should I look into to understand that behaviour?

Thanks a lot for any pointers and suggestions!

[Marwes]

That should have been a compilation error (see #873)

[crides]

I think you meant #874, but yeah I see what you mean. So basically there can be no zero argument functions in Gluon?

Edit: And it works now by making the primitive! call to take 1 argument instead of 0.

[Marwes]

Yeah, the implementation still exists since IO actions are implemented as zero argument functions under the hood but I will see if I can't make it so zero argument functions only work for IO actions to prevent this mistake.

(Technically there is only 1-argument functions in gluon, two argument functions are just a 1 argument function that returns a function that takes 1 argument, (+) : Int -> (Int -> Int) )

[crides]

I was testing other things, and while this is not my original problem, it seems to be in the same vein. If I change the imports to be in a record, then the function is only called once.

// ...
    let res = vm.run_expr::<()>(
        "test",
        r#"
let counter @ { ? } = import! test
counter.inc_counter ()
counter.inc_counter ()
        "#,
    );
// ...

In this case, the before & after pair is only shown once, and the counter at the end is 1.

Also, what should I look into if I need to debug further problems like this?

[Marwes]

Are you using 0.17.1, this may be an optimizer issue on lower versions.

[crides]

I was using 0.15.0, but I just tested on 0.17.1, and the issue persists.