interface ITest {
mut:
	caller(a Test) !
}

struct Test {
}

struct Test2 {
}

fn (t2 Test2) with_reader(func fn (a Test) !) ! {
	return func(Test{})
}

fn (t Test) caller(a Test) ! {
	println('ok')
}

fn get() ITest {
	return Test{}
}

fn test_main() {
	mut a := get()

	b := Test2{}
	b.with_reader(a.caller)!
	assert true
}

interface ClosureCommand {
	value() int
mut:
	increment()
}

struct MutableClosureCommand {
mut:
	value_ int
}

fn (cmd MutableClosureCommand) value() int {
	return cmd.value_
}

fn (mut cmd MutableClosureCommand) increment() {
	cmd.value_++
}

fn with_closure_connection(func fn () !) ! {
	func()!
}

fn with_closure_writer(func fn () !) ! {
	func()!
}

fn with_closure_reader(func fn () !) ! {
	func()!
}

fn write_closure_command(cmd ClosureCommand) ! {
	assert cmd.value() == 41
}

fn read_closure_command(mut cmd ClosureCommand) ! {
	cmd.increment()
}

fn process_closure_command(mut cmd ClosureCommand) ! {
	with_closure_connection(fn [mut cmd] () ! {
		with_closure_writer(fn [cmd] () ! {
			write_closure_command(cmd)!
		})!
		with_closure_reader(fn [mut cmd] () ! {
			read_closure_command(mut cmd)!
		})!
	})!
}

fn test_nested_closure_captures_mut_interface_by_value() {
	mut cmd := ClosureCommand(MutableClosureCommand{
		value_: 41
	})
	process_closure_command(mut cmd)!
	assert cmd.value() == 42
}