// Go 1.26 及之前
func (r *Rand) Int32N(n int32) int32
func (r *Rand) Int64N(n int64) int64
func (r *Rand) IntN(n int) int
func (r *Rand) Uint32N(n uint32) uint32
func (r *Rand) Uint64N(n uint64) uint64

// Go 1.27
type intType interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64 |
    ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
}

func (r *Rand) N[Int intType](n Int) Int

package main

import "fmt"

// 定义一个泛型栈
type Stack[T any] struct {
    items []T
}

func (s *Stack[T]) Push(v T) {
    s.items = append(s.items, v)
}

func (s *Stack[T]) Pop() (T, bool) {
    if len(s.items) == 0 {
        var zero T
        return zero, false
    }
    v := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return v, true
}

// 泛型方法：引入新的类型参数 U
// Map 将栈中每个元素通过函数 f 转换为 U 类型，返回新的 Stack[U]
func (s *Stack[T]) Map[U any](f func(T) U) *Stack[U] {
    result := &Stack[U]{}
    result.items = make([]U, len(s.items))
    for i, v := range s.items {
        result.items[i] = f(v)
    }
    return result
}

// 泛型方法：Reduce 折叠操作
func (s *Stack[T]) Reduce[U any](initial U, f func(U, T) U) U {
    acc := initial
    for _, v := range s.items {
        acc = f(acc, v)
    }
    return acc
}

func main() {
    s := &Stack[int]{}
    s.Push(1)
    s.Push(2)
    s.Push(3)

    // Map: int -> string，类型自动推导
    strStack := s.Map(func(v int) string {
        return fmt.Sprintf("num-%d", v)
    })

    // Reduce: 求和
    sum := s.Reduce(0, func(acc, v int) int {
        return acc + v
    })
    fmt.Printf("Sum: %d
", sum) // 输出: Sum: 6

    // 嵌套调用
    result := s.Map(func(v int) float64 {
        return float64(v) * 1.5
    }).Reduce(0.0, func(acc float64, v float64) float64 {
        return acc + v
    })
    fmt.Printf("Mapped sum: %.1f
", result) // 输出: Mapped sum: 9.0
}

type Habitat struct {
    Burrow string
}

type Gopher struct {
    Name    string
    Habitat // 嵌入结构体
}

// Go 1.27 之前：必须嵌套初始化
g1 := Gopher{
    Name: "Gopher",
    Habitat: Habitat{
        Burrow: "Burrow #42",
    },
}

// Go 1.27：可以直接使用嵌入字段的字段名
g2 := Gopher{
    Name:   "Gopher",
    Burrow: "Burrow #42",
}

func GenericFormatter[T any](v T) string {
    return fmt.Sprintf("value: %v", v)
}

type IntFormatter func(int) string

// Go 1.27 在复合字面量、类型转换、通道发送中自动推导 T
formatters := []IntFormatter{GenericFormatter} // T = int
fn := IntFormatter(GenericFormatter)            // T = int
ch := make(chan IntFormatter, 1)
ch <- GenericFormatter                          // T = int

// Go 1.26 的风格：包级函数嵌套
result := Reduce(
    Map(
        Filter(numbers, func(n int) bool { return n > 0 }),
        func(n int) float64 { return float64(n) * 1.1 },
    ),
    0.0,
    func(acc float64, v float64) float64 { return acc + v },
)

// Go 1.27 的风格：方法链
result := NewSlice(numbers).
    Filter(func(n int) bool { return n > 0 }).
    Map(func(n int) float64 { return float64(n) * 1.1 }).
    Reduce(0.0, func(acc, v float64) float64 { return acc + v })

// 泛型构建器：在构建过程中改变类型
type QueryBuilder[T any] struct {
    sql    string
    args   []any
}

func Query[T any](table string) *QueryBuilder[T] {
    return &QueryBuilder[T]{sql: fmt.Sprintf("SELECT * FROM %s", table)}
}

// ScanTo 是一个泛型方法，将结果映射到新类型 U
func (q *QueryBuilder[T]) ScanTo[U any](mapper func(T) U) *QueryBuilder[U] {
    // 这里保留 SQL，改变目标类型
    return &QueryBuilder[U]{sql: q.sql, args: q.args}
}

func (q *QueryBuilder[T]) Where(cond string, args ...any) *QueryBuilder[T] {
    q.sql += " WHERE " + cond
    q.args = append(q.args, args...)
    return q
}

type Validator[T any] struct{}

func (v *Validator[T]) Validate(value T) error {
    // 基础验证逻辑
    return nil
}

// 泛型方法：添加字段级验证
func (v *Validator[T]) Field[F any](
    getter func(T) F,
    fieldName string,
    rules ...func(F) error,
) *Validator[T] {
    // 注册字段验证规则
    return v
}

package main

import (
    "fmt"
    "encoding/json/v2"
)

type User struct {
    Name  string `json:"name"`
    Age   int    `json:"age"`
    Email string `json:"email,omitempty"`
}

func main() {
    u := User{Name: "Alice", Age: 30}

    // v2 使用 Options 控制编码行为
    opts := json.Options{
        EscapeHTML:  true,
        Multiline:   true,   // 美化输出
        Indent:      "  ",
    }

    data, err := opts.Marshal(u)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(data))

    // 严格模式：遇到未知字段时报错
    strictOpts := json.Options{
        RejectUnknownFields: true,
    }

    input := []byte(`{"name":"Bob","age":25,"unknown":"field"}`)
    var user User
    err = strictOpts.Unmarshal(input, &user)
    // 输出: json: unknown field "unknown"
    fmt.Println(err)
}

package main

import (
    "fmt"
    "uuid"
)

func main() {
    // 生成 V4 随机 UUID
    v4 := uuid.New()
    fmt.Printf("UUIDv4: %s
", v4)
    fmt.Printf("  版本: %d
", v4.Version())

    // 生成 V7 时间排序 UUID（适合数据库主键）
    v7 := uuid.NewV7()
    fmt.Printf("UUIDv7: %s
", v7)
    fmt.Printf("  时间: %v
", v7.Time())

    // 解析 UUID
    parsed, err := uuid.Parse("550e8400-e29b-41d4-a716-446655440000")
    if err == nil {
        fmt.Printf("解析成功: %s (版本 %d)
", parsed, parsed.Version())
    }
}

// 概念示例：SIMD 向量加法
import "golang.org/x/exp/simd"

func addFloat64(a, b []float64) []float64 {
    result := make([]float64, len(a))
    simd.Map(func(x, y float64) float64 {
        return x + y
    }, result, a, b)
    return result
}

传统模式: 模板 → 渲染函数 → VNode → Diff → Patch → 真实DOM
Vapor模式: 模板 → 原生DOM操作指令 → 真实DOM

<!-- 原始模板 -->
<template>
  <div class="container">
    <h1>{{ title }}</h1>
    <p>这是静态文本，永远不会变</p>
    <button @click="count++">点击了 {{ count }} 次</button>
  </div>
</template>

// 传统虚拟DOM模式的编译结果（简化示意）
import { createElementBlock, openBlock, toDisplayString } from 'vue'

function render(_ctx, _cache) {
  return (openBlock(), createElementBlock("div", { class: "container" }, [
    createElementVNode("h1", null, toDisplayString(_ctx.title), 1 /* TEXT */),
    createElementVNode("p", null, "这是静态文本，永远不会变"),
    createElementVNode("button", { onClick: _cache[0] || (_cache[0] = $event => (_ctx.count++)) }, "点击了 " + toDisplayString(_ctx.count) + " 次", 9 /* TEXT, PROPS */)
  ]))
}

// Vapor Mode 的编译结果（简化示意）
import { setText, setAttr, on, template as tmpl } from 'vue/vapor'

const t0 = tmpl('<div class="container"><h1></h1><p>这是静态文本，永远不会变</p><button></button></div>')

function render(_ctx) {
  const n0 = t0()
  const n1 = n0.firstChild // h1
  const n2 = n1.nextSibling // p (静态)
  const n3 = n2.nextSibling // button

  // 细粒度响应式绑定：title 变化时只更新 h1 的文本
  _ctx.$effect(() => setText(n1, _ctx.title()))

  // 点击事件直接绑定
  on(n3, "click", () => _ctx.count.set(_ctx.count.get() + 1))

  // count 变化时只更新按钮文本
  _ctx.$effect(() => setText(n3, "点击了 " + _ctx.count() + " 次"))

  return n0
}

// vite.config.js
import { defineConfig } from 'vite'
import vue from '@vitejs/plugin-vue'

export default defineConfig({
  plugins: [
    vue({
      vapor: true // 全局启用 Vapor Mode
    })
  ]
})

<!-- 对单个组件启用 Vapor Mode -->
<template vapor>
  <div>这个组件使用 Vapor Mode 编译</div>
</template>

<!-- 对单个组件显式禁用 Vapor Mode -->
<template vapor="false">
  <div>这个组件使用传统虚拟DOM</div>
</template>

<template vapor>
  <div class="todo-app">
    <h2>待办事项 ({{ todos().length }})</h2>
    
    <div class="input-group">
      <input 
        type="text" 
        :value="newTodo()"
        @input="newTodo.set($event.target.value)"
        @keyup.enter="addTodo"
        placeholder="添加新任务..."
      />
      <button @click="addTodo">添加</button>
    </div>

    <ul class="todo-list">
      <li v-for="todo in todos()" :key="todo.id" class="todo-item">
        <input 
          type="checkbox" 
          :checked="todo.done"
          @change="toggleTodo(todo.id)"
        />
        <span class="todo-text" :class="{ done: todo.done }">
          {{ todo.text }}
        </span>
        <button class="delete-btn" @click="deleteTodo(todo.id)">
          删除
        </button>
      </li>
    </ul>

    <div class="stats">
      <span>已完成: {{ completedCount() }}</span>
      <span>未完成: {{ activeCount() }}</span>
    </div>
  </div>
</template>

<script setup>
import { ref, computed } from 'vue/vapor'

const newTodo = ref('')
const nextId = ref(1)

const todos = ref([
  { id: 0, text: '学习 Vue Vapor Mode', done: true },
  { id: 1, text: '重构项目列表组件', done: false },
])

const completedCount = computed(() => 
  todos.value.filter(t => t.done).length
)

const activeCount = computed(() => 
  todos.value.filter(t => !t.done).length
)

function addTodo() {
  const text = newTodo.value.trim()
  if (!text) return
  
  todos.value.push({
    id: nextId.value++,
    text,
    done: false
  })
  newTodo.value = ''
}

function toggleTodo(id) {
  const todo = todos.value.find(t => t.id === id)
  if (todo) {
    todo.done = !todo.done
  }
}

function deleteTodo(id) {
  todos.value = todos.value.filter(t => t.id !== id)
}
</script>

<style scoped>
.todo-app {
  max-width: 500px;
  margin: 0 auto;
  padding: 20px;
}
.todo-item {
  display: flex;
  align-items: center;
  gap: 10px;
  padding: 8px 0;
  border-bottom: 1px solid #eee;
}
.todo-text.done {
  text-decoration: line-through;
  color: #999;
}
</style>

// 开发者写的代码
function ShoppingCart({ items, currency }) {
  const total = calculateTotal(items, currency)
  const discount = getDiscount(items.length)
  const finalPrice = total - discount

  function handleCheckout() {
    api.checkout(items, finalPrice)
  }

  return (
    <div>
      <ItemList items={items} />
      <TotalDisplay total={total} discount={discount} />
      <button onClick={handleCheckout}>结算</button>
    </div>
  )
}

// React Compiler 编译后的等效代码（示意）
function ShoppingCart({ items, currency }) {
  // 自动记忆化：只有 items 和 currency 变化时才重新计算
  const total = useMemo(
    () => calculateTotal(items, currency),
    [items, currency]
  )
  
  const discount = useMemo(
    () => getDiscount(items.length),
    [items.length]
  )
  
  const finalPrice = useMemo(
    () => total - discount,
    [total, discount]
  )

  // 自动记忆化：回调函数
  const handleCheckout = useCallback(
    () => {
      api.checkout(items, finalPrice)
    },
    [items, finalPrice]
  )

  // 自动记忆化：子组件 props
  const itemList = useMemo(
    () => <ItemList items={items} />,
    [items]
  )

  return (
    <div>
      {itemList}
      <TotalDisplay total={total} discount={discount} />
      <button onClick={handleCheckout}>结算</button>
    </div>
  )
}

<script>
  // Svelte 5 Runes
  let count = $state(0);
  let doubled = $derived(count * 2);
  
  $effect(() => {
    console.log(`count 变成了 ${count}`);
  });
</script>

<button onclick={() => count++}>
  {count} x 2 = {doubled}
</button>

// Rust 1.98：定义 C 可变参数函数
use std::ffi::VaList;

extern "C" {
    fn vprintf(fmt: *const i8, ap: VaList) -> i32;
}

// 实现一个 C 可变参数函数
pub unsafe extern "C" fn my_printf(fmt: *const i8, mut args: ...) -> i32 {
    vprintf(fmt, args.as_va_list())
}

use std::fmt::NumBuffer;

fn main() {
    let mut buf = NumBuffer::new();
    
    // 无堆分配的整数格式化
    let s = 42.format_into(&mut buf);
    assert_eq!(s, "42");
    
    // 支持所有整数类型
    let s = (-12345_i64).format_into(&mut buf);
    assert_eq!(s, "-12345");
}

// 使用 wasm-bindgen 的 Rust 前端代码示例
use wasm_bindgen::prelude::*;
use web_sys::console;

#[wasm_bindgen]
pub struct DataProcessor {
    data: Vec<f64>,
}

#[wasm_bindgen]
impl DataProcessor {
    #[wasm_bindgen(constructor)]
    pub fn new(data: Vec<f64>) -> Self {
        Self { data }
    }

    pub fn compute_statistics(&self) -> Statistics {
        let sum: f64 = self.data.iter().sum();
        let mean = sum / self.data.len() as f64;
        let variance: f64 = self.data.iter()
            .map(|x| (x - mean).powi(2))
            .sum::<f64>() / self.data.len() as f64;
        
        Statistics {
            mean,
            variance,
            std_dev: variance.sqrt(),
        }
    }
}

#[wasm_bindgen]
pub struct Statistics {
    pub mean: f64,
    pub variance: f64,
    pub std_dev: f64,
}