struct Point {
mut:
    x int
    y int
}

fn (mut p Point) translate[T](x T, y T) {
    p.x += x
    p.y += y
}

fn test_generic_method() {
    mut pot := Point{}
    pot.translate[int](1, 3)
    pot.translate(1, 3)
    println(pot)
    assert pot == Point{
        x: 2
        y: 6
    }
}

struct Person {
mut:
    name string
}

fn (mut p Person) show[T](name string, data T) string {
    p.name = name
    return 'name: ${p.name}, data: ${data}'
}

fn test_generic_method_with_fixed_arg_type() {
    mut person := Person{}
    res := person.show('bob', 10)
    assert res == 'name: bob, data: 10'
}

struct Foo {}

fn (v Foo) new[T]() T {
    return T{}
}

fn test_generic_method_with_map_type() {
    foo := Foo{}
    mut a := foo.new[map[string]string]()
    assert a == map[string]string{}
    assert a.len == 0
    a['a'] = 'a'
    assert a.len == 1
    assert a['a'] == 'a'
}

fn test_generic_method_with_array_type() {
    foo := Foo{}
    mut a := foo.new[[]string]()
    assert a == []string{}
    assert a.len == 0
    a << 'a'
    assert a.len == 1
    assert a[0] == 'a'
}

fn test_generic_method_with_struct_type() {
    foo := Foo{}
    mut a := foo.new[Person]()
    a.name = 'a'
    assert a.name == 'a'
}

struct MethodArrayPtrTest {
    a string
}

struct MethodArrayPtrDecoder {}

fn (mut d MethodArrayPtrDecoder) decode_array[T](mut val []T) {
    val << T{}
}

fn (mut d MethodArrayPtrDecoder) decode_value[T](mut val T) {
    $if T is $array {
        d.decode_array(mut val)
    }
}

fn test_generic_method_array_of_ptr_generic_inference() {
    mut d := MethodArrayPtrDecoder{}
    mut a := []&MethodArrayPtrTest{}
    d.decode_value(mut a)
    assert a.len == 1
}