Function that accepts generic struct

Is it possible to have my function definition below accept any type of struct?

I've tried to refactor like so:

// This method should accept any type of struct
// Once I receive my response from the database,
// I scan the rows to create a slice of type struct.

func generateResponse(rows *sqlx.Rows, structSlice []struct{}, structBody struct{}) ([]struct{}, error) {
	for rows.Next() {

		err := rows.StructScan(&structBody)

		if err != nil {
			return nil, err
		}

		structSlice = append(structSlice, structBody)

	}

	err := rows.Err()
	if err != nil {
		return nil, err
	}

	return structSlice, nil
}

Assume my struct is of type OrderRevenue.

When I call the function above:

structSlice, err := generateResponse(rows, []OrderRevenue{}, OrderRevenue{})

The error I get is:

cannot use []OrderRevenue literal as type []struct{} in argument...

Am I going about this the wrong way?

This is considered the cornerstone (or more of a limitation) of Go's type system. struct{} is an unnamed type that is different from struct{ field1 int } and of course is not the same as OrderRevenue{}.

Go emphasizes abstraction through interfaces, and perhaps you should try that. Here is the first take:

  type OrderRevenue interface {
          MarshalMyself() ([]byte, error)
  }

  type Anonymous struct {}
  func (a Anonymous) MarshalMyself() ([]byte, error) {
          // implementation's up to you
          return []byte{}, nil
  }

  // the function signature
  generateResponse(rows *sqlx.Rows, structSlice []OrderRevenue, structBody Body) ([]Body, error) {
          // ...
  }

In this case you can also use empty interface interface{}, which all types implement, but you'll have to recursively go through the structure to do manual type assertion. The best approach in Go is to know the shape of your data in advance, at least partially.

maybe you can use the reflection to check whether your argument is a struct or not.

///some codes	
v := reflect.TypeOf(structBody)
if v.Kind() != reflect.Struct {
	return nil, fmt.Errorf("argument is not a struct")
}
///some codes

and you use generic to specify the types of your parameters

func generateResponse[t any](rows *sqlx.Rows, structSlice []t, structBody t) ([]t, error) {

 v := reflect.TypeOf(structBody)
 if v.Kind() != reflect.Struct {
	return nil, fmt.Errorf("argument is not a struct")
 }

for rows.Next() {
   
    err := rows.StructScan(&structBody)

    if err != nil {
        return nil, err
    }

    structSlice = append(structSlice, structBody)

}

err := rows.Err()
if err != nil {
    return nil, err
}

return structSlice, nil

}