GoLang - Generics : Create variable in generic function

I am Very new to Golang (came from Java background). I am trying to create a variable(object) type for interface Writer in a generic function and try to call interface function in same generic function which create the variable(object).

Could Not able to proceed since struck with below case. Please help me.

Thanks.

package main
import "fmt"
type Writer interface {
Write(message string)
Print(message string)
Test()
}
type FileLogger struct {
ID int
}
func (f *FileLogger) Write(message string) {
fmt.Println("Writing:", message)
f.Test()
}
func (f *FileLogger) Print(message string) {
fmt.Println("Logging:", message)
}
func (f *FileLogger) Test() {
fmt.Println("Called Test:")
}
type SecondLogger struct {
FileLogger
}
func (f *SecondLogger) Print(message string) {
fmt.Println("SecondLogger:", message)
}
func (f *SecondLogger) Test() {
fmt.Println("Updated Test")
}
type ThirdLogger struct {
SecondLogger
}
func (f *ThirdLogger) Test() {
fmt.Println("ThirdLogger Test")
}
func CreateLogger[T Writer]() *T {
temp := new(T)
temp.Test()
temp.Write("Hello, World!")
return temp
}
func main() {
var writer Writer
writer = CreateLogger[FileLogger]()//Error
writer.Print("This is a log message.")
writer = CreateLogger[SecondLogger]()//Error
writer.Print("2nd log message.")
writer = CreateLogger[ThirdLogger]()//Error
writer.Print("3rd log message.")
writer.Test()
}

Update :
Expectation:

Using same createLogger Function I could able to create object for all 3 type of struct while creating itself should be able call to Test() function

You don't need golangs latest generics feature to do this. You can achieve this just using interface concepts. Here is the code. Go Playground

package main
import "fmt"
type Writer interface {
Write(message string)
Print(message string)
Test()
}
type FileLogger struct {
ID int
}
func (f *FileLogger) Write(message string) {
fmt.Println("Writing:", message)
f.Test()
}
func (f *FileLogger) Print(message string) {
fmt.Println("Logging:", message)
}
func (f *FileLogger) Test() {
fmt.Println("Called Test:")
}
type SecondLogger struct {
FileLogger
}
func (f *SecondLogger) Print(message string) {
fmt.Println("SecondLogger:", message)
}
func (f *SecondLogger) Test() {
fmt.Println("Updated Test")
}
type ThirdLogger struct {
SecondLogger
}
func (f *ThirdLogger) Test() {
fmt.Println("ThirdLogger Test")
}
func CreateLogger(kind interface{}) Writer {
switch kind.(type) {
case FileLogger:
return &FileLogger{}
case SecondLogger:
return &SecondLogger{}
// here v has type S
case ThirdLogger:
return &ThirdLogger{}
default:
return nil
}
}
func main() {
var writer Writer
writer = CreateLogger(FileLogger{})
writer.Print("This is a log message.")
writer = CreateLogger(SecondLogger{})
writer.Print("2nd log message.")
writer = CreateLogger(ThirdLogger{})
writer.Print("3rd log message.")
writer.(*ThirdLogger).Test()
}

Running your code on GoPlayground makes these errors:

./prog.go:52:7: temp.Test undefined (type *T is pointer to type parameter, not type parameter)
./prog.go:53:7: temp.Write undefined (type *T is pointer to type parameter, not type parameter)
./prog.go:60:24: FileLogger does not satisfy Writer (method Print has pointer receiver)
./prog.go:63:24: SecondLogger does not satisfy Writer (method Print has pointer receiver)
./prog.go:66:24: ThirdLogger does not satisfy Writer (method Print has pointer receiver)

Lets handle them:

These part of errors occurs because of using pointers for calling interface functions:

./prog.go:60:24: FileLogger does not satisfy Writer (method Print has pointer receiver)
./prog.go:63:24: SecondLogger does not satisfy Writer (method Print has pointer receiver)
./prog.go:66:24: ThirdLogger does not satisfy Writer (method Print has pointer receiver)

So, below changing is needed:

• func (f *FileLogger) Write to func (f FileLogger) Write
• func (f *FileLogger) Print to func (f FileLogger) Print
• func (f *FileLogger) Test to func (f FileLogger) Test
• func (f *SecondLogger) Print to func (f SecondLogger) Print
• func (f *SecondLogger) Test to func (f SecondLogger) Test
• func (f *ThirdLogger) Test to func (f ThirdLogger) Test

With the above update, those three lines of errors will disappear.

But the interesting thing (which is caused by the use of pointers in Golang language) is by prevent using generic creator function (and create them directly), there is no need to do the above updates and using Pointers doesn't cause any errors.

(However, consider that those functions are not going to make any changes to their caller structs, so there is no need to use pointers)

Lets go on these:

./prog.go:52:7: temp.Test undefined (type *T is pointer to type parameter, not type parameter)
./prog.go:53:7: temp.Write undefined (type *T is pointer to type parameter, not type parameter)

These errors occurs because of declaring func CreateLogger[T Writer]() *T.
GoLang has slightly different Interface approach from Java.
In Java, when a class implements an interface, it is considered to be a kind of that interface. This concept is based on the principles of object-oriented programming (OOP) and inheritance.
But by temp := new(T) inside func CreateLogger[T Writer], you are creating a Writer, not FileLogger or SecondLogger or ThirdLogger (in GoLang, the structs that implements an interface methods, are not considered as kind of the interface like Java). Also as mentioned in errors, using new(T), creates pointer to type parameter, not type parameter.

So, using @shahriar-ahmeds answer helps you by prevent using generic features, but if you insist implementing generics creator function, one way is using reflect:

func CreateLogger[T Writer]() T {
// Create a default model of type T
var temp T
// Check if the type T implements the Writer interface
if reflect.TypeOf(temp).Implements(reflect.TypeOf((*Writer)(nil)).Elem()) {
// Call the Test method if it exists
if testFunc, ok := reflect.TypeOf(temp).MethodByName("Test"); ok {
reflect.ValueOf(temp).Method(testFunc.Index).Call(nil)
}
// Call the Write method if it exists
if writeFunc, ok := reflect.TypeOf(temp).MethodByName("Write"); ok {
reflect.ValueOf(temp).Method(writeFunc.Index).Call([]reflect.Value{reflect.ValueOf("Hello, World!")})
}
}
return temp
}

You can see and run the final updated code in this GoPlayground link.