type ProcedureHandler = fn () !string

struct Procedure[T, U] {
    value    T
    function fn (T) !U = unsafe { nil }
}

fn (p Procedure[T, U]) handle() !string {
    result := p.function(p.value) or { return err }
    return encode[U](result)
}

fn encode[T](value T) string {
    $if T is Dog {
        return 'dog:${value.name}'
    }
    $if T is Cat {
        return 'cat:${value.name}'
    }
    return 'unknown'
}

struct Dog {
    name string
}

struct NewDog {
    name string
}

fn make_dog(value NewDog) !Dog {
    return Dog{
        name: value.name
    }
}

struct Cat {
    name string
}

struct NewCat {
    name string
}

fn make_cat(value NewCat) !Cat {
    return Cat{
        name: value.name
    }
}

fn test_generic_fn_field_multi_instance_specialization() {
    dog := Procedure[NewDog, Dog]{
        value:    NewDog{'leo'}
        function: make_dog
    }
    cat := Procedure[NewCat, Cat]{
        value:    NewCat{'milo'}
        function: make_cat
    }
    handlers := [ProcedureHandler(dog.handle), ProcedureHandler(cat.handle)]
    assert (handlers[0]() or { panic(err) }) == 'dog:leo'
    assert (handlers[1]() or { panic(err) }) == 'cat:milo'
}