struct Test[T] {
	v T
}

fn get_test[T](v T) Test[T] {
	return Test[T]{
		v: v
	}
}

fn test_generics_assign_generics_struct() {
	x1 := get_test(1)
	println('${x1.v}')
	assert x1.v == 1

	x2 := get_test(2.2)
	println('${x2.v}')
	assert x2.v == 2.2

	x3 := get_test('aaa')
	println('${x3.v}')
	assert x3.v == 'aaa'

	x4 := get_test(true)
	println('${x4.v}')
	assert x4.v == true
}

// test generics assign generics struct_init
struct Node[T] {
pub mut:
	val  T
	next &Node[T] = unsafe { nil }
}

fn new[T]() &Node[T] {
	return &Node[T]{}
}

fn (mut n Node[T]) add(val T) {
	node := &Node[T]{val, unsafe { nil }}
	n.next = node
}

fn test_generic_fn_assign_generic_struct_init() {
	mut list1 := new[int]()
	list1.add(100)
	println(list1.next)
	assert list1.next.val == 100

	mut list2 := new[f64]()
	list2.add(2.22)
	println(list2.next)
	assert list2.next.val == 2.22

	mut list3 := new[bool]()
	list3.add(false)
	println(list3.next)
	assert list3.next.val == false

	mut list4 := new[string]()
	list4.add('aaa')
	println(list4.next)
	assert list4.next.val == 'aaa'
}