How can non-struct type extends struct functions

update: Ok I made it wrong. CustomJSONType's functions can not access the fields of the struct that it is embedded into, for which both User and IntList should define Scan and Value of their own or try other workarounds.

original post on 2021-6-21

I am using GORM and trying to define some custom types like User and IntList.

type User struct {
	Id	    int
	Name    string
	Email   string
}

type IntList []int

And as is known GORM custom type must implement Value and Scan functions. Here's what I did - I defined a CustomJSONType which implements Value and Scan like this:

type CustomJSONType struct {}

func (t *CustomJSONType) Scan(src interface{}) error {
	bytes, ok := src.([]byte)
	if !ok {
		return errors.New("invalid input type")
	}
	err := json.Unmarshal(bytes, t)
	if err != nil{
		return err
	}
	return nil
}

func (t CustomJSONType) Value() (driver.Value, error) {
	bytes, err := json.Marshal(t)

	if err != nil {
		return []byte{}, err
	}
	return bytes, err
}

func (t CustomJSONType) GormDataType() string {
	return "json"
}

To equip User with Value and Scan, all I have to do is to add a single line to the definition of User:

update: it won't work as CustomJSONType can't access fields of User

type User struct {
    CustomJSONType
	Id	    int
	Name    string
	Email   string
}

However, I have no idea how to extend IntList with CustomJSONType. I have to explicitly define Scan and Value for IntList. Even at best I can wrap the implementation of Value and Scan as independent functions but still have to write signatures for Scan and Value in IntList. Any suggestions to define IntList just as simple as User?

There is no "inherit" concept in golang but only combination. Don't like normal OOP language, the struct CustomJSONType can't access the data from IntList and User, so the method CustomJSONType.Value can't serialize other types than itself. If you want implement a method once and use it anywhere, I provide an idea bellow.

package main

import (
	"database/sql/driver"
	"encoding/json"
	"errors"
	"fmt"
)

type CustomJSONType struct {
	data interface{}
}

func (t *CustomJSONType) Scan(src interface{}) error {
	bytes, ok := src.([]byte)
	if !ok {
		return errors.New("invalid input type")
	}
	err := json.Unmarshal(bytes, t.data)
	if err != nil{
		return err
	}
	return nil
}

func (t CustomJSONType) Value() (driver.Value, error) {
	bytes, err := json.Marshal(t.data)

	if err != nil {
		return []byte{}, err
	}
	return bytes, err
}

func (t CustomJSONType) GormDataType() string {
	return "json"
}

type User struct {
	Id      int
	Name    string
	Email   string
}

type Project struct {
	user CustomJSONType
}

func (p *Project) SetUser(u User) {
	p.user.data = u
}

func (p *Project) GetUser() User {
	user := p.user.data.(User)
	return user
}

Not sure if I understood you correctly. But you can combine several types, including an array of ints, without creating a structure. They remain a type and are available in functions. But combining types requires a structure, which is why you cannot directly use array addressing.

type IntArr []int
type AnyStruct struct{
Uses bool
}
type TestIntArrStruct struct{
IntArr
AnyStruct
}
func(arr *IntArr) Add(i ...int){
*arr = append(*arr, i...)
}
func(anyStruct *AnyStruct) Invert(){
anyStruct.Uses = !anyStruct.Uses
}
var a TestIntArrStruct
a.Add(1,2,3)
a.Invert()

You can see it here:
https://play.golang.org/p/MF5eMcgmeak