一些特定功能的泛型函数例子。



## Contains

判断某元素是否包含在指定 slice 中。
```go
func Contains[E comparable](s []E, v E) bool {
	for _, vs := range s {
		if v == vs {
			return true
		}
	}
	return false
}
```

官方 exp 包的实现：[Contains](https://cs.opensource.google/go/x/exp/+/master:slices/slices.go;l=115)

## Reverse

反向 slice 中的元素。
```go
func Reverse[E any](s []E) []E {
	result := make([]E, 0, len(s))
	for i := len(s) - 1; i >= 0; i-- {
		result = append(result, s[i])
	}
	return result
}
```

官方 exp 包的实现：[Reverse](https://cs.opensource.google/go/x/exp/+/master:slices/slices.go;l=510)

## Sort

```go
func Sort[E constraints.Ordered](s []E) []E {
	result := make([]E, len(s))
	copy(result, s)
	sort.Slice(result, func(i, j int) bool {
		return result[i] < result[j]
	})
	return result
}
```

官方 exp 包的实现：[Sort](https://cs.opensource.google/go/x/exp/+/master:slices/sort.go;l=15)

## Map

这里的 map 指把一个值映射为另一个值。
```go
type mapFunc[E any] func(E) E

func Map[E any](s []E, f mapFunc[E]) []E {
	result := make([]E, len(s))
	for i := range s {
		result[i] = f(s[i])
	}
	return result
}

// 映射函数使用了标准库函数 ToUpper
func Upper() {
	s := []string{"a", "b", "c"}
	fmt.Println(Map(s, strings.ToUpper))
}
```

## Filter

从 slice 中找出要保留的元素。
```go
type keepFunc[E any] func(E) bool

func Filter[E any](s []E, f keepFunc[E]) []E {
	result := []E{}
	for _, v := range s {
		if f(v) {
			result = append(result, v)
		}
	}
	return result
}

func IsEven[T constraints.Integer](v T) bool {
	return v%2 == 0
}

func TestEven() {
	s := []int{1, 2, 3, 4}
	// 使用字面量
	fmt.Println(Filter(s, func(v int) bool {
		return v%2 == 0
	}))
	// 使用泛型函数
	fmt.Println(Filter(s, IsEven[int]))
}

```

## Reduce

用于合并 slice 中的元素，比如对 slice 中的数字求和。
```go
type reduceFunc[E any] func(cur, next E) E

func Reduce[E any](s []E, init E, f reduceFunc[E]) E {
	cur := init
	for _, v := range s {
		cur = f(cur, v)
	}
	return cur
}

// 求和
func Sum() {
	s := []int{1, 2, 3, 4}
	sum := Reduce(s, 0, func(cur, next int) int {
		return cur + next
	})
	fmt.Println(sum)
}
```

其他 reduce 操作
```go
// 
func Multiplication() {
	s := []int{1, 2, 3, 4}
	p := Reduce(s, 1, func(cur, next int) int {
		return cur * next
	})
	fmt.Println(p)
}

func JoinString() {
	s := []string{"a", "b", "c"}
	j := Reduce(s, "", func(c, n string) string {
		return c + n
	})
	fmt.Println(j)
}

```

泛型化 Go 函数

一些使用泛型类型的例子。



## 类型定义

对现有类型重新定义是允许的，这么做可以对类型重新起一个意思明确的名字，并且可以在其上定义方法：
```go
type MyInt int
type Port int
```

但是对`[T any]`重新定义是不允许的，从设计上来说，对任意类型重新起名字没什么用。
```go
type MyT[T any] T
//              ^
// cannot use a type parameter as RHS in type declaration
```

## Slices

```go
type Bunch[E any] []E
// 在使用时实例化
b := Bunch[int]{1, 2, 3}
```

## Go 中没有泛型类型

在代码中所定义的泛型类型，在编译时都会实例化为具体类型。

## 使用 interface 实例化泛型类型

```go
type Bunch[E any] []E

var b Bunch[error]
b = append(b, errors.New("oh no"))

fmt.Println(b)
// [oh no]
```

## Maps

```go
type Catalog[V any] map[string]V

cat := Catalog[int]{}
fmt.Println(cat["bogus"])
// 0
```

## 多类型参数

```go
// 对于 map 来说，key 必须是 comparable 的
type Index[K comparable, V any] map[K]V

age := Index[string, int]{}
age["John"] = 29
fmt.Println(age["John"])
// 29
```

## Structs

```go
type NamedThing[T any] struct {
	Name  string
	Thing T
}

n := NamedThing[float64]{
    Name:  "Latitude",
    Thing: 50.406,
}
fmt.Println(n)
// {Latitude 50.406}

// 嵌套泛型类型
p := NamedThing[NamedThing[float64]]{
    Name: "Position",
    Thing: NamedThing[float64]{
        Name:  "Latitude",
        Thing: 50.406,
    },
}
fmt.Println(p)
// {Position {Latitude 50.406}}
```

## Methods

```go
type Bunch[E any] []E
// 方法的 receiver 上不用写约束
func (b Bunch[E]) First() E {
	return b[0]
}

b := Bunch[string]{"a", "b", "c"}
fmt.Println(b.First())
// a
```

## 零值

```go
func (b Bunch[E]) First() E {
	var zero E
	if len(b) == 0 {
		return zero
	}
	return b[0]
}
```

## 方法上的类型参数

不允许这种定义：
```go
func (b Bunch[E]) PrintWith[T any](v T) {
	fmt.Println(v, b)
}
// methods cannot have type parameters
```

## Interfaces

```go
type Equaler[T any] interface {
	Equal(T) bool
}
```

## Channels

```go
type myChan[E any] chan E

ch := make(myChan[error])
go func() {
    ch <- errors.New("oh no")
}()
fmt.Println(<-ch)
// oh no
```

泛型化 Go 的原生类型

`[T any]`上其实没有任何约束，其效果等同于`interface{}`。虽然`T`可以是任何类型，但是由于`any`不能反应出任何特征，所以在其上的操作非常受限，比如不能进行如下操作：
```go
func Add[T any](x, y T) T {
	return x + y
//         ^
// invalid operation: operator + not defined on x (variable of type T constrained by any)
}
```



## 方法集

在 Go 中定义约束就是定义接口。下面的例子使用了标准库`fmt.Stringer`接口约束类型参数。
```go
// packge fmt
type Stringer interface {
       String() string
}

// 约束
func Stringify[T fmt.Stringer](s T) string {
       return s.String()
}
```

## 命名类型

在泛型出来以前，interface 中只能包含方法。泛型出来后 interface 被用于约束类型参数，并且其不仅可以包含方法，还可以包含其他类型，下面的例子展示了 interface 包含 int 类型：
```go
type OnlyInt interface {
       int
}

// 使用
func Double[T OnlyInt](v T) T {
       return v * 2
}
```

## 类型联合

通过类型联合来扩大约束范围，可以看成`or`操作，可以包含 interface 或者其他约束。
```go
type Integer interface {
       int | int8 | int16 | int32 | int64
}

type Float interface {
       float32 | float64
}

type Complex interface {
       complex64 | complex128
}

type Number interface {
       Integer | Float | Complex
}
```

## 类型集

满足某个约束的所有类型的集合。

## 复合类型字面量

在约束中使用匿名 struct：
```go
type Pointish interface {
       struct{ X, Y int }
}
```

注意，虽然约束中明确指出 struct 包含 X，Y，但是不能在函数中使用，[参考](https://github.com/golang/go/issues/51576)
```go
func GetX[T Pointish](p T) int {
	return p.X
//           ^
// p.X undefined (type T has no field or method X)
}
```

## 约束 vs 接口

就目前来说，所有的接口都可以作为约束，但是约束不能当接口用，比如函数参数：
```go
func Double(p Number) Number {
//            ^       ^
// cannot use type Number outside a type constraint: interface contains type constraints
}
```

## 约束不是类

```go
type Cow struct{ moo string }

type Chicken struct{ cluck string }

type Animal interface {
	Cow | Chicken
}

type Farm[T Animal] []T

func Foo() {
	_ = Farm[Cow]{}
	_ = Farm[Chicken]{}
	_ = Farm[Animal]{}
//           ^
// cannot use type Animal outside a type constraint: interface contains type constraints
}
```

报错的原因就是约束并不是类型，无法用于泛型实例化。

## 命名类型的限制

```go
type Integer interface {
	int | int8 | int16 | int32 | int64
}

type MyInt int

func Double[T Integer](v T) T {
	return v * 2
}

func Foo() {
	fmt.Println(Double(MyInt(1)))
//              ^
// MyInt does not satisfy Integer (possibly missing ~ for int in Integer)
}
```

上面的代码无法编译通过，由于通过类型定义，MyInt 不是 int，所以对于有相同底层类型的类型来说，无法传递约束中未出现的具有相同底层类型的值。

## 类型近似

想要解决上面的问题可以使用`~`符号，其含义是包含当前类型及其具有相同底层类型的类型。
```go
type ApproximatelyInt interface {
       ~int
}
```

类型近似也可以用在复合类型字面量上：
```go
type Pointish interface {
       ~struct{ x, y int }
}
```

## 类型交集

在定义接口时每行为一个方法，其含义是，若要实现该接口则需要某类型实现该接口中的所有方法。对于约束来说，如果某类型想要满足一个约束，那么需要其满足该约束的所有要求。

对于下面的约束，没有任何类型能满足，因为不可能有一个类型同时是`int && string`。
```go
type Unpossible interface {
    int
	string
}
```

想要解决这个问题可以使用类型近似：
```go
type IntStringer interface {
       ~int
       fmt.Stringer
}
```

## constraints 包

官方的实验性包 [constraints](https://pkg.go.dev/golang.org/x/exp/constraints) 包含了一些有用的约束：
- Complex
- Float
- Integer
- Ordered
- Signed
- Unsigned

### 算术

```go
package product

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

type Number interface {
	constraints.Integer | constraints.Float | constraints.Complex
}

func Product[T Number](x, y T) T {
	return x * y
}

package product_test

import (
	"product"
	"testing"

	"github.com/google/go-cmp/cmp"
	"github.com/google/go-cmp/cmp/cmpopts"
)
func TestProductOfInts2And3Is6(t *testing.T) {
	t.Parallel()
	want := 6
	got := product.Product(2, 3)
	if !cmp.Equal(want, got) {
		t.Error(cmp.Diff(want, got))
	}
}
```

### 大小比较

可以使用`>`、`<`、`>=`、`<=`

```go
package main

import (
	"fmt"

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

func main() {
	fmt.Println(Greater("a", "b"))
}

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

/*
packge contraints

type Ordered interface {
	Integer | Float | ~string
}
*/
```

### 多个类型参数

```go
func Identity[T, U any](x T, y U) (T, U) {
       return x, y
}
```

### 相等比较

有些类型不能大小比较（ordered），但是可以相等比较（comparable）。
- bool
- struct 中的字段需要都是可相等比较的
- complex numbers, pointers, channels, arrays, and interfaces.

由于很多类型无法预定义到约束中（比如用户自定义的 struct），所以 constraints 包中并没有 comparable 约束，而是直接把 comparable 内置为关键字，利用编译器进行检查。
```go
func Equal[T comparable](x, y T) bool {
	return x == y
}
```

### 找最大值

```go
package main

import (
	"fmt"

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

func Max[E constraints.Ordered](s []E) E {
	var max E
	for _, e := range s {
		if e > max {
			max = e
		}
	}
	return max
}

func main() {
	s := []string{"faith", "hope", "love"}
	fmt.Println(Max(s))
}
```

### 抽象类型及其零值

上面的 Max 在其 body 中使用了类型参数 E，这个 E 被称为抽象类型。有时想返回其零值，可以使用如下方法：
```go
var max E
return max

// 如果约束允许也可以使用这个方法
return E(0)
```

## 约束字面量

一些例子：
```go
// 空约束
func Identity[T interface{}](v T) T {}
// 包含一个方法
func Stringify[T interface{ String() string }](s T) string {
       return s.String()
}
```

### 省略 interface

当约束中只有一个类型元素时，可以省略`interface{...}`
```go
func Increment[T ~int](v T) T {
       return v + 1
}

// 下面的是错误示例
func Increment[T ~int; ~float64](v T) T {
   // syntax error: unexpected semicolon, expecting comma or ]
func Increment[T String() string](v T) T {
   // syntax error: unexpected (, expecting comma or ]
type Intish ~int
   // syntax error: unexpected ~ in type declaration
```

## 自引用约束

```go
func Contains[T interface{ Equal(T) bool }](s []T, v T) bool {}

type Equaler interface {
       Equal(Equaler) bool
}
```

Go 泛型约束

类型参数使用`[T any]`来声明，通过在类型名称或函数名称后面声明类型参数来使其泛型化。



## 泛型函数

在函数名后面定义类型参数`[T any]`，然后在参数列表中使用该类型。

```go
// 定义泛型函数
func PrintAnythingTo[T any](w io.Writer, d T) {
	fmt.Fprintln(w, d)
}

// 使用泛型函数
func TestPrintAnythingTo_PrintsInputToSuppliedWriter(t *testing.T) {
	t.Parallel()
	buf := &bytes.Buffer{}
	print.PrintAnythingTo[string](buf, "Hello, world")
	want := "Hello, world\n"
	got := buf.String()
	if !cmp.Equal(want, got) {
		t.Error(cmp.Diff(want, got))
	}
}
```

## 复合类型

```go
// 获取任意 slice 的长度
func Len[E any](s []E) int ()
// 参数为 receive-only chan
func Drain[E any](ch <-chan E) {}
func Merge[E any](chs ...<-chan E) <-chan E {}
```

## 泛型类型

**泛型 slice**

```go
// 声明
type Bunch[E any] []E
// 使用
b := Bunch[int]{1, 2, 3}

// 错误的使用
b := Bunch[int]{1, 2, 3}
b = append(b, "hello")
   // cannot use "hello" (untyped string
   // constant) as int value in argument
   // to append
```

**泛型函数类型**

```go
// 正确的声明
type idFunc[T any] func(T) T
// 错误的声明
type idFunc func[T any](T) T
   // syntax error: function type must have no type parameters
```

**泛型类型作为函数参数**

和上面的复合类型类似，只不过参数是泛型类型。

```go
// 泛型类型
type Group[E any] []E
// 泛型函数
func Len[E any](s Group[E]) int {
	return len(s)
}

// 使用
func TestLenOfGroupIs2WhenItContains2Elements(t *testing.T) {
	t.Parallel()
	g := group.Group[int]{1, 2}
	want := 2
	got := group.Len(g)
	if !cmp.Equal(want, got) {
		t.Error(cmp.Diff(want, got))
	}
}
```

Go 类型参数

我们最常见的冠心病、高血压、糖尿病、肿瘤、抑郁症、气管炎、哮喘、慢性肾病等疾病，都是由不恰当的生活方式引起的，医学工作者将这些疾病统一归类为慢性非传染性疾病，简称“慢病”。



## 疾病的本质：细胞损伤速度超过修复速度

人的一生中，体内大部分细胞都在不断更新，通过再生来修复损伤，这一生就是一个细胞不断自我修复的过程。而生病的本质，就是细胞损伤的速度超过了细胞修复的速度。不健康的心理、不合理的饮食、运动、睡眠等生活方式都会影响细胞的修复速度。

主流的治疗慢性病的方法是对抗疗法：血压高了用降压药，血糖高了用降糖药，肿瘤长出来了切除，哮喘用抗哮喘药，等等。但是对抗疗法是针对外来因素的疾病，例如外伤，病毒感染导致的疾病，常采用止血、抗炎、抢救和预防接种等方式，但并不适用于慢病。

慢病来源于各种不平衡，比如缺乏睡眠、长期吸烟、大量饮酒、不运动或者运动过量，饮食不平衡、压力太大，这些生活方式就是对细胞进行损伤，而给细胞修复提供原料的只有饮食。

人体细胞的自我修复能力取决于两个主要因素，一个是与生俱来的细胞生命周期，另一个是后天的营养状况。所以想要防止慢病可以从两方面入手，减少对细胞的损伤（健康的生活方式），以及正确的营养方向。

## 修复细胞损伤的唯一原料：食物中的营养素

普通人都知道饮食要均衡丰富，从医学的角度来描述营养，其包含七大营养素：
- 碳水化合物（又称为糖类，包括葡萄糖、果糖、麦芽糖、淀粉等）
- 蛋白质（分为必需氨基酸和非必需氨基酸）
- 脂类（分为脂肪和类脂，脂肪又叫甘油三酯，分为必需脂肪酸和非必需脂肪酸；类脂包括磷脂、胆固醇、胆固醇脂、糖脂）
- 维生素（分为脂溶性维生素和水溶性维生素）
- 矿物质（分为常量元素和微量元素）
- 膳食纤维（分为可溶性膳食纤维和不可溶性膳食纤维）
- 水

那人体每天都消耗了哪些营养？
1. 运动方面。经常运动的人和体力劳动者消耗的碳水化合物要更多一些。
2. 心理方面。大脑消耗的营养素与肌肉消耗的营养素不一样，用脑越多越需要多补充蛋白质、维生素、矿物质，还有脂类中的胆固醇、磷脂和DHA和EPA。
3. 熬夜。消耗的营养素会更多，如维生素A、维生素B族、磷脂和蛋白质等。
4. 吸烟。需要更多的抗氧化剂来对抗尼古丁等毒素对人体的伤害。
5. 喝酒。伤肝，需要更多的营养素来修复肝脏细胞，如维生素B族和蛋白质。

不同的人的生活方式不同，所以饮食结构也不同，所以为了健康每个人都需要掌握一点营养学知识。

## 七大营养素如何修复细胞损伤

### 细胞的结构

![](https://s2.loli.net/2024/09/08/2eTP4OXcUKq3ZpA.png)

**细胞膜**

除了水分子，许多营养素是不能随意出入的。细胞膜上的蛋白质根据DNA的指示决定对哪些营养素实行开放政策，这些被批准的营养素一定是有助于修复细胞结构或者细胞代谢的营养成分，比如氨基酸、葡萄糖、钾、钙、磷等，能转运多少要看细胞需要多少。

**细胞质**

细胞质是细胞膜包围的除核区外的一切半透明、胶状、颗粒状物质的总称。包含各种营养物质。

**细胞核**

细胞核里有DNA，记载着所有细胞应该执行的程序。细胞核的膜叫核膜，由磷脂、蛋白质、胆固醇等成分组成。这个膜上有很多孔，细胞质中的营养物质可以通过核孔进入细胞核里。核膜上有大量的多种酶，可进行各种生命活动。

**内质网**

细胞里的细胞器之一内质网，具有承担细胞内物质合成和运输的作用。比如合成蛋白质、参与激素的合成与运输，等等。

**高尔基体**

它的主要功能是将内质网合成的蛋白质进行加工、对比、分类、包装，然后分门别类地送到细胞特定的部位或分泌到细胞外。

**线粒体**

所有的细胞工作都需要能量，这些能量来源于线粒体，它通过燃烧葡萄糖来产生能量。当葡萄糖不足时燃烧脂肪，蛋白质不能直接被燃烧，要在肝脏中转化成葡萄糖以后才能成为能量。

### 七大营养素究竟为细胞做了什么呢？

**为细胞新陈代谢提供能量**

能量一般来讲感觉得到但是看不到，比如一个人走路、说话。主要靠碳水化合物类，也就是粮食、水果等。

**为新生细胞更新提供结构原料**

人体主要由蛋白质、脂类（脂肪酸、磷脂和胆固醇等）构成，同时需要维生素和矿物质的协助。主要靠蛋白质类和脂类，主要存在于肉、蛋、奶、鱼中。

**为人体新陈代谢提供媒介**

人的新陈代谢是在酶的催化下完成的。新陈代谢速度越快，需要的酶越多。酶是从哪里来的呢？是食物中的营养转化的。酶的主体部分是蛋白质，辅助部分叫作辅酶，辅酶的主要成分是维生素和矿物质。

另外，内分泌系统是调节细胞代谢的重要角色，而激素分为蛋白质类激素和胆固醇类激素，比如甲状腺素、胰岛素都属于蛋白质类激素，肾上腺素就属于胆固醇类激素。所以说一个人吃动物性食品，比如鸡蛋、内脏、肉类，里面有蛋白质和胆固醇，这些正好是形成激素前提。

主要靠蛋白质类和胆固醇类，还有维生素、矿物质。

**养肠道细菌**

肠道里尤其是结肠中存在大量细菌，体积很小，数量很多。人体由40万亿～60万亿个细胞组成，而我们身上的细菌数量是人体细胞数量的10倍，并且主要在肠道里，肠道里的细菌靠食物中的膳食纤维养活。

## 防治慢病吃什么：35%动物类食物 + 65%植物类食物

通过探究历史（感兴趣的可以看书），大概在距今2万～1万年前是旧石器时代向新石器时代转化时期，人类进化得最快。当时的饮食结构是：
- 植物性食物占65%左右，主要是水果、蔬菜、坚果、豆类和蜂蜜。
- 动物性食物占35%左右，主要是肉类、蛋类、鱼和虾贝类。

所以我们的食谱与这个时期的食谱越接近，大脑和身体就越接近理想状态：
- 尽量摄入天然食物，注意减少加工食品摄入量。
- 动物类食物（肉、蛋、奶、鱼等）最好占一天食物的35%。当然如果能买到散养的畜禽类动物或者禽卵更好。
- 植物类食物包括蔬菜、水果和粮食，占一天食物的65%。蔬菜和水果种类尽量多样化，粮食类食物种类要多，以粗粮为主，如全麦类、糙米、玉米、莜麦、薯类都很好，最不好的是精米、精面，因为精米、精面是工业化的产物。

## 防治慢病怎么吃：注重结构型营养素和营养密度

结构型营养为新生细胞更新提供结构原料，包含指磷脂、蛋白质、胆固醇。如果这些结构性营养缺失了，细胞无法按照DNA的指令完成增生和修复。

营养素在细胞中的吸收和释放都是有顺序的。食物中的碳水化合物、蛋白质和脂肪如果一同被摄入，最先被利用的一定是碳水化合物，进入细胞的线粒体，直接变为能量。蛋白质和脂肪变成细胞膜的结构或者成为某些有生物活性的物质，如酶。

一般来讲，人在饥饿时，以脂肪分解为主，占80%左右，蛋白质的分解约占20%。所以健身的时候一定要补充碳水，否则就没有蛋白质形成肌肉了。

对运动量不大的现代人来说，最好的食物选择是：低能量密度，高营养密度。如果是体力劳动者，那就要高能量密度，高营养密度。最符合低能量、高营养这一标准的膳食结构，就是地中海膳食结构。

## 参考

- [地中海饮食](https://zh.wikipedia.org/wiki/%E5%9C%B0%E4%B8%AD%E6%B5%B7%E9%A3%B2%E9%A3%9F)