module main

import strings

pub struct MyStruct[T] {
pub mut:
    result T
}

pub fn (it MyStruct[T]) indent_str[T]() string {
    mut res := strings.new_builder(32)
    res.write_string('${it.result}')
    return res.str()
}

fn test_generics_str_intp() {
    x := MyStruct[int]{
        result: 100
    }

    y := MyStruct[string]{
        result: 'hello'
    }

    assert x.indent_str() == '100'
    assert y.indent_str() == 'hello'
}

struct Foo[T] {
    bar T
}

fn (b Foo[T]) str() string {
    return '${b.bar:b}/${b.bar:o}/${b.bar:d}/${b.bar:x}'
}

fn generic_int_format[T](value T) string {
    return '${value:b}/${value:o}/${value:d}/${value:x}'
}

fn generic_int_padded_format[T](value T) string {
    return '${value:08x}/${value:+d}'
}

// vfmt off
fn generic_default_format[T](value T) string {
    return '${value:_}'
}
// vfmt on

fn test_generic_string_interpolation_explicit_int_formats() {
    assert generic_int_format[int](42) == '101010/52/42/2a'
    assert generic_int_padded_format[int](42) == '0000002a/+42'
    assert generic_default_format[int](42) == '42'
    assert generic_default_format[string]('ok') == 'ok'

    baz := Foo[int]{
        bar: 42
    }
    assert baz.str() == '101010/52/42/2a'

    baz_inferred := Foo{
        bar: 56
    }
    assert baz_inferred.str() == '111000/70/56/38'
}