// 泛型
// 使用类型形参编写 Go 函数以处理多种类型
// comparable 是一个内置 Constraint(约束)，用来表示类型形参可以接收的类型实参的种类，所谓的“约束”就是指，T 被约束为可以使用哪几种类型。
// comparable 包含所有可以比较类型，包括：booleans、numbers、strings、pointers、channels、可比较的 arrays、structs 中的属性
// comparable 可以改为 any，表示 T 可以是任意类型
func Index[T comparable](s []T, x T) int {
 for i, v := range s {
  // 这里的 v 和 x 都是 T 类型
  // 若上层调用时，传进来的 T 的约束类型为 string，则 s 和 x 也是 string 类型；若传进来的 T 的约束类型为 int，则 s 和 x 也是 int 类型
  if v == x {
   return i
  }
 }
 return -1
}

func main() {
 // Index() 函数适用于 int 类型的切片
 si := []int{10, 20, 15, -10}
 fmt.Println(Index[int](si, 15))

 //  Index() 函数同样也使用于 string 类型的切片
 ss := []string{"foo", "bar", "baz"}
 fmt.Println(Index[string](ss, "hello"))
}

func IndexInt(s []int, x int) int {
    // Do Somthing
}

func IndexString(s []string, x string) int {
    // Do Somthing
}

func Do[R any, S any, T any](a R, b S) T {
  // Do Somthing
}
func main() {
  fmt.Println(Do[int, uint, float64](1, 2))
}

// 上面的代码的行为与下面的函数完全相同:
// Do(a int, b uint) float64

var db *gorm.DB

func initDB() {
 var err error
 db, err = gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
 if err != nil {
  panic("failed to connect database")
 }

 db.AutoMigrate(&UserGorm{}, &ProductGorm{})
}

type ProductGorm struct {
 gorm.Model
 Name  string
 Price uint
}

func (p *ProductGorm) Create(db *gorm.DB) error {
 return db.Create(p).Error
}

// 由于该 struct 必须要实现 interface，所以，该 struct 的方法不像泛型可以直接返回一个泛型类型 T。只能返回 interface{}
func (p *ProductGorm) Get(db *gorm.DB, id uint) (interface{}, error) {
 var pg ProductGorm
 err := db.Where("id = ?", id).First(&pg).Error
 return pg, err
}

type UserGorm struct {
 gorm.Model
 FirstName string
 LastName  string
}

// 不使用泛型的情况下，每个新的 struct 都要写一遍 Create 和 Get，哪怕 Create 和 Get 中的逻辑一样。
func (u *UserGorm) Create(db *gorm.DB) error {
 return db.Create(u).Error
}

func (u *UserGorm) Get(db *gorm.DB, id uint) (interface{}, error) {
 var ug UserGorm
 err := db.Where("id = ?", id).First(&ug).Error
 return ug, err
}

// 在这个示例中，接口只是为了与 handlingData 搭配展示类似泛型一样的参数传递。并不一定要使用接口
// type SQLExecutor interface {
//  Create(db *gorm.DB) error
//  Get(db *gorm.DB, id uint) (interface{}, error)
// }

// func handlingData(e SQLExecutor, db *gorm.DB, id uint) {
//  e.Create(db)
//  fmt.Println(e.Get(db, id))
// }

func main() {
 initDB()

 p := &ProductGorm{
  Name:  "product",
  Price: 100,
 }

 u := &UserGorm{
  FirstName: "first",
  LastName:  "last",
 }

 // 并不需要 handlingData() 函数来演示不使用泛型的效果，
 // 只是用了接口后，添加该函数可以展现出接口中类似泛型一样的可以传递任意类型的效果
 // handlingData(p, db, 1)
 // handlingData(u, db, 1)

 // 不使用泛型，需要给每个结构体都编写一遍相同的方法。
 p.Create(db)
 fmt.Println(p.Get(db, 1))

 u.Create(db)
 fmt.Println(u.Get(db, 1))
}

type ProductGorm struct {
 gorm.Model
 Name  string
 Price uint
}

type UserGorm struct {
 gorm.Model
 FirstName string
 LastName  string
}

// 由泛型结构体统一处理
type SQLExecutor[T any] struct {
 db *gorm.DB
}

// 通用的处理器
// ！！！最关键的是通过泛型的使用！！！
// ！！！代码整体上少写了很多 Create 和 Get。尤其是当还需要添加更多 strcut 时，节省的代码量会非常多！！！
func NewSQLExecutor[T any](db *gorm.DB) *SQLExecutor[T] {
 return &SQLExecutor[T]{
  db: db,
 }
}

func (e *SQLExecutor[T]) Create(t *T) error {
 return e.db.Create(t).Error
}

func (e *SQLExecutor[T]) Get(id uint) (*T, error) {
 var t T
 err := e.db.Where("id = ?", id).First(&t).Error
 return &t, err
}

// 这个函数只是为了与使用接口对比而设计的，真实用法不是这样的。
// func handlingData[T any](e *SQLExecutor[T], p *T) {
//  e.Create(p)
//  fmt.Println(e.Get(1))
// }

func main() {
 initDB()

 p := &ProductGorm{
  Name:  "product",
  Price: 100,
 }

 u := &UserGorm{
  FirstName: "first",
  LastName:  "last",
 }

 // 泛型的最佳时机，就是当两个“对象”的某些“方法”的行为完全一样时，我们可以通过泛型来声明这些方法，以防止重复编写完全相同的代码。
 // 就像下面这段代码中，ProductGorm 与 UserGorm 的两个方法代码其实是完全相同的，如果使用 interface{}，那么我们需要重复写 Create() 与 Get() 方法。
 // 其实，本质上 ProductGorm 与 UserGorm 所需要执行的 SQL 是完全一样，不一样的只是其中的列名而已。
 ep := NewSQLExecutor[ProductGorm](db)
 ep.Create(p)
 fmt.Println(ep.Get(1))

 eu := NewSQLExecutor[UserGorm](db)
 eu.Create(u)
 fmt.Println(eu.Get(1))

 // 使用 handlingData() 只是为了与不使用泛型的示例中，添加了接口的使用示例保持一致，以方便对比。
 // handlingData(NewSQLExecutor[ProductGorm](db), p)
 // handlingData(NewSQLExecutor[UserGorm](db), u)
}

func Min(x, y float64) float64 {
    if x < y {
        return x
    }
    return y
}

import "golang.org/x/exp/constraints"

func GMin[T constraints.Ordered](x, y T) T {
    if x < y {
        return x
    }
    return y
}

x := GMin[int](2, 3)

fmin := GMin[float64]
m := fmin(2.71, 3.14)

type Tree[T interface{}] struct {
    left, right *Tree[T]
    value       T
}

func (t *Tree[T]) Lookup(x T) *Tree[T] { ... }

var stringTree Tree[string]