fn neg(a int) int {
	return -a
}

struct FnHolder1<T> {
	func T
}

fn (self FnHolder1<T>) call(a int) int {
	return self.func(a)
}

struct FnHolder2<T> {
	func fn (int) int
}

fn (self FnHolder2<T>) call(a int) int {
	return self.func(a)
}

fn holder_call_1<T>(func T, a int) int {
	h := FnHolder1{func}
	return h.call(a)
}

fn holder_call_2<T>(func T, a int) int {
	h := FnHolder2{func}
	return h.call(a)
}

fn holder_call_11<T>(func T, a int) int {
	f := func
	h := FnHolder1{f}
	return h.call(a)
}

fn holder_call_21<T>(func T, a int) int {
	f := func
	h := FnHolder2{f}
	return h.call(a)
}

fn holder_call_12<T>(func T, a int) int {
	return FnHolder1{func}.call(a)
}

fn holder_call_22<T>(func T, a int) int {
	return FnHolder2{func}.call(a)
}

fn main() {
	mut ret := holder_call_1(neg, 1)
	assert ret == -1
	ret = holder_call_11(neg, 2)
	assert ret == -2
	ret = holder_call_12(neg, 3)
	assert ret == -3
	ret = FnHolder1{neg}.call(4)
	assert ret == -4

	ret = holder_call_2(neg, 3)
	assert ret == -3
	ret = holder_call_21(neg, 4)
	assert ret == -4
	ret = holder_call_22(neg, 5)
	assert ret == -5
	ret = FnHolder2{neg}.call(6)
	assert ret == -6
}
