我用的是 pomerium ，直接把所有需要验证的服务都丢到反向代理后面去就行了

@mayli #1 我的整个 .venv 文件夹都是 Excluded...

我理解的跟你一样，这种情况下虽然 go 的 race 检查会报错但是实际上是安全的

并没有 panic

顺便前面#1 和#3 理解错了，这里操作的 a 是个*A ，跟 string 和 A 的大小没关系。

你不用 unsafe ，不用 arena 之类的东西的话一般不会有内存泄漏。一般泄漏的都是 fd 、socket 、goroutine 之类的东西。

不一定。没办法确定，只能自己看对应的配置文件。

一般来说 scoop 会把应用的持久化文件保存到对应应用的文件夹下面，但是不能保证不会读写注册表。

@drymonfidelia #8 你首先要理解 baseXX 的意义，是把原始数据作为一个大整数然后进行进制转换。

base62 ，base63 跟 base65 可能差不多，但是 base64 有独特的性质。64=2^6 ，byte 的 255=2^8 意味着每 3 字节的原始数据一定能编码为 4 字节的 base64 。

所以 base64 可以每 4byte 进行处理，用现成的 uint32 就行。换成 base62 你就要处理一个不定长的 big int ，因为 62 不是 2 的幂，没有 base64 这样的性质。

码表长度是 2 的整数次方当然有加成啊，这意味着不需要进行大整数运算。

只用一个节点消费？

没登录的时候有反爬

@Elaina #61 那 map[string]int 要不要改尖括号啊？

@Trim21 #38

arXiv:2005.11710v4

Featherweight Go

Recently, the Go team mooted a design to extend Go with generics [Taylor and Griesemer 2019],
and Rob Pike wrote Wadler to ask:

Would you be interested in helping us get polymorphism right (and/or figuring out
what “right” means) for some future version of Go?

range over func 设计的不好是真的，怎么连泛型都反对，还把 Rob Pike 拿出来。

Rob Pike 本人并不反对泛型，现在的泛型是 Phil Wadler 实现，这位是 Rob Pike 当年的同事，就是 Rob Pike 请来的。Rob Pike 自己说过没有泛型的情况下有些事情做起来效率低下。

golang 为了不加这个 yield 关键词真是煞费苦心…

这个新功能还有个离谱的地方是标准库里 iter.Pull 的实现方法，直接魔改运行时…

@james122333 有啊

@james122333 这里说的 Result 是提供判断是否为 Error 还是为 result 的能力的，同时判断两者为 nil 就是非 error 并且 *T 为 nil 的情况啊？

这里说的这个 Result 在 go 里是不存在的，不是结构体那样的东西。结构体和多返回值是一回事。

@james122333 #111 除非你在 err!=nil 的时候也返回了一个 T ，否则我们说的 Result 是涵盖了你说的这种情况的。

@james122333 #108

你说的这几个其实都不是问题。

单返回值也可以表示 return nil, nil ， 只要这个 Result 是 *T | Error 就行。你是想的 int | Error 不能 nil ，nil ，但你定义为 *int | Error 肯定可以 nil ，nil 。nil 也是一个 *int 。

所以 rust 的解决方法是加了一个 ? 操作符，在 Err 时候直接把 Err 返回上层，中止当前函数。

@yu1miao #100 准确的说这里有 6 种情况，你 benchmark 跑一下就能看出来泛型实现的问题了。

这里跟 writeGeneric 直接传结构体的性能跟用接口，并且编译器没有进行 devirtualize 是相同的，并不会像你说的那样专门生成一个 writeGeneric(w *Buffer) error

如果你传进去的是一个接口，调用开销直接就翻倍了。


func Benchmark_interface_0(b *testing.B) {
var buf = &Buffer{}
for i := 0; i < b.N; i++ {
write(buf)
}
}

func Benchmark_interface_1(b *testing.B) {
var buf io.ByteWriter = &Buffer{}
for i := 0; i < b.N; i++ {
write(buf)
}
}

func Benchmark_interface_2(b *testing.B) {
var buf IBuffer = &Buffer{}
for i := 0; i < b.N; i++ {
write(buf)
}
}

func Benchmark_generic_0(b *testing.B) {
var buf = &Buffer{}
for i := 0; i < b.N; i++ {
writeGeneric(buf)
}
}

func Benchmark_generic_1(b *testing.B) {
var buf io.ByteWriter = &Buffer{}
for i := 0; i < b.N; i++ {
writeGeneric(buf)
}
}

func Benchmark_generic_2(b *testing.B) {
var buf IBuffer = &Buffer{}
for i := 0; i < b.N; i++ {
writeGeneric(buf)
}
}

Benchmark_interface_0-16 232742709 5.139 ns/op 0 B/op 0 allocs/op
Benchmark_interface_1-16 434387566 2.794 ns/op 0 B/op 0 allocs/op
Benchmark_interface_2-16 85636600 14.67 ns/op 0 B/op 0 allocs/op
Benchmark_generic_0-16 85636600 13.97 ns/op 0 B/op 0 allocs/op
Benchmark_generic_1-16 54496902 24.23 ns/op 0 B/op 0 allocs/op
Benchmark_generic_2-16 49954623 24.91 ns/op 0 B/op 0 allocs/op