Go 语言中和类型Sum Types的创新实现方案详解

// TypeScript 示例
type Shape = 
  | { kind: "circle"; radius: number; color: string }
  | { kind: "rectangle"; width: number; height: number; color: string };

[
  { "kind": "circle", "color": "red", "radius": 1 },
  { "kind": "rectangle", "color": "green", "width": 15, "height": 15 }
]

┌─────────────────────────────────────────────────────┐
│  shape (私有)：完整字段 + json tag                 │
│  → 用于 JSON 编解码（唯一需要 json tag 的 struct）  │
└─────────────────────────────────────────────────────┘
           ↓ unsafe.Pointer 转换（零成本）
┌─────────────────────────────────────────────────────┐
│  Shape (公有)：仅暴露公共字段（Color/Kind）        │
│  → 通用操作入口                                     │
└─────────────────────────────────────────────────────┘
           ↓ unsafe.Pointer 转换（零成本）
┌─────────────────────────────────────────────────────┐
│  CircleShape / RectangleShape (公有)：              │
│  按 kind 暴露特定字段（Radius / Width+Height）     │
│  → 类型安全的字段访问                               │
└─────────────────────────────────────────────────────┘

// shape 用于 JSON 编解码（唯一含 json tag 的 struct）
type shape struct {
	shapeCaster // 必须是第一个字段，用于方法“继承”
	Color *string `json:"color,omitempty"`
	Kind  *string `json:"kind,omitempty"`  // discriminator
	Radius *int `json:"radius,omitempty"`   // circle 专用
	Width  *int `json:"width,omitempty"`    // rectangle 专用
	Height *int `json:"height,omitempty"`   // rectangle 专用
}

// Shape：通用投影（仅暴露公共字段）
type Shape struct {
	shapeCaster
	Color *string
	Kind  *string
	_     *int // Radius（隐藏）
	_     *int // Width（隐藏）
	_     *int // Height（隐藏）
}
// CircleShape：circle 专用投影
type CircleShape struct {
	shapeCaster
	Color *string
	Kind  *string
	Radius *int  // 仅此字段暴露
	_     *int  // Width（隐藏）
	_     *int  // Height（隐藏）
}
// RectangleShape：rectangle 专用投影
type RectangleShape struct {
	shapeCaster
	Color *string
	Kind  *string
	_     *int  // Radius（隐藏）
	Width  *int
	Height *int
}

type shapeCaster struct{}
// 安全转换：*Shape → *CircleShape（运行时检查 kind）
func (sc *shapeCaster) Circle(s *Shape) *CircleShape {
	if s.Kind == nil || *s.Kind != "circle" {
		panic("not a circle")
	}
	return (*CircleShape)(unsafe.Pointer(s))
}
// 类型转换：*RectangleShape → *CircleShape（修改 kind + 重置字段）
func (sc *shapeCaster) SetCircle(r *RectangleShape) *CircleShape {
	*r.Kind = "circle"
	*r.Radius = 0    // 重置 rectangle 专用字段
	*r.Width = 0
	*r.Height = 0
	return (*CircleShape)(unsafe.Pointer(r))
}

func main() {
	jsonData := []byte(`[
		{"kind":"circle","color":"red","radius":1},
		{"kind":"rectangle","color":"green","width":15,"height":15}
	]`)
	// 1. 直接反序列化到 []*Shape（无需自定义 UnmarshalJSON！）
	var shapes []*Shape
	json.Unmarshal(jsonData, &shapes) // ✅ 一次反序列化完成
	// 2. 类型安全处理
	for _, s := range shapes {
		switch *s.Kind {
		case "circle":
			c := s.Circle() // 安全转换到 CircleShape
			fmt.Printf("Circle: radius=%d\n", *c.Radius)
		case "rectangle":
			r := s.Rectangle()
			// 编译时保证只能访问 Width/Height，无法误用 Radius
			if *r.Width > 10 {
				r.Width = ptr(10)
			}
		}
	}
	// 3. 直接序列化回 JSON（无需自定义 MarshalJSON！）
	result, _ := json.MarshalIndent(shapes, "", "  ")
	fmt.Println(string(result))
}

package main
import (
	"encoding/json"
	"fmt"
	"unsafe"
)
// ===== 核心类型定义 =====
type shapeCaster struct{}
func (sc *shapeCaster) Circle(s *Shape) *CircleShape {
	if s.Kind == nil || *s.Kind != "circle" {
		panic("not a circle")
	}
	return (*CircleShape)(unsafe.Pointer(s))
}
func (sc *shapeCaster) Rectangle(s *Shape) *RectangleShape {
	if s.Kind == nil || *s.Kind != "rectangle" {
		panic("not a rectangle")
	}
	return (*RectangleShape)(unsafe.Pointer(s))
}
// 私有：用于 JSON 编解码
type shape struct {
	shapeCaster
	Color  *string `json:"color,omitempty"`
	Kind   *string `json:"kind,omitempty"`
	Radius *int    `json:"radius,omitempty"`
	Width  *int    `json:"width,omitempty"`
	Height *int    `json:"height,omitempty"`
}
// 公有：通用投影
type Shape struct {
	shapeCaster
	Color  *string
	Kind   *string
	_      *int // Radius
	_      *int // Width
	_      *int // Height
}
// 公有：Circle 投影
type CircleShape struct {
	shapeCaster
	Color  *string
	Kind   *string
	Radius *int
	_      *int // Width
	_      *int // Height
}
// 公有：Rectangle 投影
type RectangleShape struct {
	shapeCaster
	Color  *string
	Kind   *string
	_      *int // Radius
	Width  *int
	Height *int
}
// 辅助函数
func ptr[T any](v T) *T { return &v }
// ===== 主程序 =====
func main() {
	jsonData := []byte(`[
		{"kind":"circle","color":"red","radius":1},
		{"kind":"rectangle","color":"green","width":15,"height":15}
	]`)
	// 直接反序列化（无需自定义 UnmarshalJSON）
	var shapes []*Shape
	if err := json.Unmarshal(jsonData, &shapes); err != nil {
		panic(err)
	}
	// 类型安全处理
	for i, s := range shapes {
		fmt.Printf("\nShape #%d (kind=%s):\n", i, *s.Kind)
		switch *s.Kind {
		case "circle":
			c := s.Circle()
			fmt.Printf("  → Circle with radius=%d\n", *c.Radius)
			// 编译器阻止：c.Width 不存在！
		case "rectangle":
			r := s.Rectangle()
			fmt.Printf("  → Rectangle %dx%d\n", *r.Width, *r.Height)
			// 安全修改
			if *r.Width > 10 {
				r.Width = ptr(10)
				fmt.Println("    (width capped to 10)")
			}
		}
	}
	// 序列化回 JSON
	result, _ := json.MarshalIndent(shapes, "", "  ")
	fmt.Println("\nModified JSON:")
	fmt.Println(string(result))
}