Pass struct method as fn argument

[duarteroso]

Description

In high level languages it is possible to pass a method from a class/struct as an argument

An example from C# (Unity pays my rent...):

using System;
					
public class Program
{	
        // Struct with a method
	class Data
	{
		public void foo() { Console.WriteLine("foo"); }
	}
	
        // A method
	static void bar() { Console.WriteLine("bar"); }
	
        // Calback talking a method with no
        // argument and returning nothing
	static void callback(Action cb)
	{
		cb();
	}
	
	public static void Main()
	{
		Data d = new Data();
		callback(d.foo); // Prints 'foo'
		callback(bar); // Prints 'bar'
	}
}

It would be nice to have this also allowed in Vlang. Perhaps it is in the works, perhaps it is a bug, I am opening it as a feature nevertheless.

Code

A snippet of a similar code that isn't compiling as of 0.1.29:

module main

type FnCallback = fn () 

// Struct with a method
struct Data { }
fn (data &Data) foo() { println('foo') }

// A method
fn bar () { println('bar') }

// Calback talking a method with no
// argument and returning nothing
fn callback(cb FnCallback) {
	cb()
}

fn main() {
	d := Data{}
	callback(bar) // OK
	callback(d.foo) // Nyet
}

Error

Currently this snippet is throwing this error:

 error: type `Data` has no field or method `foo`
   21 |     d := Data{}
   22 |     callback(bar)
   23 |     callback(d.foo)
      |                ~~~
   24 | }

[duarteroso]

Do give a bit of context, I am calling a C function to set a callback.
Because I can't pass a struct method there is no way to work on useful data once the callback is triggered.

type FnKey = fn (window &C.GLFWwindow, key_id, scan_code, action, bit_filed int)

fn C.glfwSetKeyCallback(window &C.GLFWwindow, callback FnKey) FnKey

struct Keyboard {
    // Internal state
}

fn (k &Keyboard) update (window &C.GLFWwindow, key_id, scan_code, action, bit_filed int) { 
    // update keyboard internal state 
}

fn update (window &C.GLFWwindow, key_id, scan_code, action, bit_filed int) { 
    // can't do much
}

fn main() {
    k := Keyboard{}
    data := C.GLFWwindow{}

    C.glfwSetKeyCallback(data, update) // useless to me
    C.glfwSetKeyCallback(data, k.update) // more useful

    // ...
}

[JalonSolov]

My first question: Is it really necessary to use glfw? That was removed from V a while ago. Yes, it's still around, but...

[duarteroso]

If I do a wrapper around GLFW for my own purposes? :)
You can replace C.glfwSetKeyCallback with any other C function that takes a function pointer and the problem remains.

[JalonSolov]

Oh, no problem if you want to use it, I was just curious. It always seemed to be problematic before.

In any case, yes, it should be looked into.

[duarteroso]

It is my believe that this has been implemented already. Shall I close this discussion?

[JalonSolov]

If your code works with current V, then yes, we can close the discussion.