Simplify Capturing Variables for Callback Functions in Odin

[rowbyte]

I deal with a lot of Callback functions I find myself needing a little more helper function/syntax sugar in Odin to make it easier. Take the following example -

CallerFn ::  proc (user_data : rawptr , proc(user_data : rawptr))

A simple proc that takes a user_data pointer and a callback function. I usually end up capturing variables to use them in the callback like the following -

//x,y,mem,data,color,hash - these are variables that were already declared in a parent scope

//declare a temp struct
_Tuple_s :: struct {
	x:      type_of(x),
	y:      type_of(y),
	mem:    type_of(mem),
	data:   type_of(data),
	color:  type_of(color),
	hash: 	type_of(hash),
}
//now capture them
tuple: _Tuple_s = {
	x=x,
	y=y,
	mem=mem,
	data=data,
	color=color,
	hash=hash,
}



CallerFn(&tuple,proc(user_data: rawptr){
	using ref := cast(^_Tuple_s)(user_data)

	//now use the captures
	x,y,mem,data,color,hash
})

The using keyword is really helpful. But currently one has to declare a struct and then capture them in two steps. Just combining these two steps into just one step would be very helpful.
Like the following perhaps

tuple := capture_vars(x,y,mem,data,color,hash) //this magic function returns a struct with all the fields and variable names



{
   TupleType :: type_of(tuple)
   CallerFn(&tuple,proc(user_data: rawptr){
	using ref := cast(^TupleType)(user_data)

	//now use the captures
	x,y,mem,data,color,hash
  })
}

Now this is still explicitly capturing the variables and the programmer has to manage all the lifetimes explicitly unlike C++. This is just creating a struct on the fly.

[Beefster09]

Seconded. While our BDFL wants to discourage the use of functional paradigms, a syntax for anonymous structs would help a lot for this and some other use cases, and if kept sufficiently simple would still keep enough friction in place to deter heavy use of captures and callbacks.

I propose something like the following syntax:

cap := struct{?} {  // The ? is inspired by the [?]T{} array syntax
    x, y,   // names two fields of the struct x and y, with the same types as the variables in scope, then sets the value of each to match the variables in scope. Captures by value.
    &foo,  // names the field foo, sets its type to ^type_of(foo), and then sets its value to &foo. Captures by pointer
    mem := raw_data(buffer),  // defines a field called 'mem', infers its type, and then sets its value to raw_data(buffer)
    i: int,  //defines a field called 'i' with type int set to zero
    s: string = "flibbertygibbet",  // does exactly what you'd expect
}

It's a little richer than the magic function you proposed and would add some complexity to the parser, but it also allows some broader use cases beyond local captures since you could use it to namespace constants and other things.

[Beefster09]

One potential issue this opens for this particular use case and syntax is that you wouldn't be able to apply an allocator for cases where you can't store the captures on the stack without adding an explicit copy call after the anonymous struct initialization.

[rowbyte]

I think making the capture struct stack only is good enough. One can easily copy to heap allocated memory if needed.

[rowbyte]

Just to add a bit - Odin already has a similar language feature for #soa_zip and #soa_unzip that works with slices. This can work very similarly syntax wise.

[KoziLord]

I think I'd like to see it as its own keyword, probably something like this:

var := #capture{a, b, c, bar, baz}

[gingerBill]

Not going to happen, most likely.