interface Foo[T] {
	val T
	foo() T
}

struct Bar[T] implements Foo[T] {
	val T
}

fn (b Bar[T]) foo() T {
	return b.val
}

fn test_main() {
	b := Bar{
		val: 0
	}
	assert b.foo() == 0
}

interface Any {}

interface AInterface {
	a int
}

struct StructA {
mut:
	a int
}

struct Container {
mut:
	any Any
}

fn (mut c Container) set[T](obj Any) {
	c.any = obj
}

fn (c &Container) get[T]() !&T {
	if c.any is T {
		return c.any
	}
	return error('ops')
}

fn test_generic_interface_value_can_be_returned_as_interface_ref() {
	a := &StructA{
		a: 100
	}
	b := &StructA{
		a: 200
	}
	mut c := &Container{
		any: a
	}
	c.set[StructA](b)
	c.set[AInterface](b)
	d := c.get[StructA]() or { panic(err) }
	e := c.get[AInterface]() or { panic(err) }
	assert d.a == 200
	assert e.a == 200
}

interface FilterModel {
	model string
}

interface FilterCar {
	name string
}

struct FilterCarRecord {
	name  string
	model string
}

fn collect_matching[T](mut cars []FilterCar) []T {
	mut matches := []T{}
	for mut car in cars {
		if mut car is T {
			matches << car
		}
	}
	return matches
}

fn test_generic_interface_to_interface_smartcast() {
	mut cars := []FilterCar{}
	cars << FilterCarRecord{
		name:  'Roadster'
		model: 'Tesla'
	}
	cars << FilterCarRecord{
		name:  'Corolla'
		model: 'Toyota'
	}

	models := collect_matching[FilterModel](mut cars)

	assert models.len == 2
	assert models[0].model == 'Tesla'
	assert models[1].model == 'Toyota'
}