struct Info[T] {
	data T
}

fn get_info[T](res Info[T]) string {
	return '${res}'
}

fn test_generic_struct_to_string() {
	mut ret := get_info(Info[bool]{true})
	println(ret)
	assert ret.contains('data: true')

	ret = get_info(Info[int]{123})
	println(ret)
	assert ret.contains('data: 123')

	ret = get_info(Info[f32]{f32(2.2)})
	println(ret)
	assert ret.contains('data: 2.2')

	ret = get_info(Info[f64]{2.2})
	println(ret)
	assert ret.contains('data: 2.2')

	ret = get_info(Info[string]{'aaa'})
	println(ret)
	assert ret.contains("data: 'aaa'")

	ret = get_info(Info[u64]{u64(234)})
	println(ret)
	assert ret.contains('data: 234')
}

@[heap]
struct RefNode[T] {
pub mut:
	value T
}

struct RefList[T] {
pub mut:
	node ?&RefNode[T]
}

fn (mut l RefList[T]) add(value T) {
	l.node = &RefNode[T]{
		value: value
	}
}

fn (l RefList[T]) array() []T {
	mut a := []T{}
	mut n := l.node or { return a }
	a << n.value
	return a
}

@[heap]
struct ReferencedValue {
	n int
}

fn test_generic_struct_to_string_with_reference_values() {
	mut list := RefList[&ReferencedValue]{}
	list.add(&ReferencedValue{
		n: 5
	})
	assert list.array()[0].n == 5
	assert '${list}' == 'RefList[&ReferencedValue]{
    node: &Option(RefNode[&ReferencedValue]{
        value: &ReferencedValue{
            n: 5
        }
    })
}'
	assert '${list.array()}' == '[&ReferencedValue{
    n: 5
}]'
}