Receptor de valor frente a receptor de puntero

No está muy claro para mí en cuyo caso querría usar un receptor de valor en lugar de usar siempre un receptor de puntero.
Para recapitular de los documentos:

type T struct {
    a int
}
func (tv  T) Mv(a int) int         { return 0 }  // value receiver
func (tp *T) Mp(f float32) float32 { return 1 }  // pointer receiver

Los documentos también dicen: "Para tipos como tipos básicos, porciones y estructuras pequeñas, un receptor de valores es muy barato, por lo que, a menos que la semántica del método requiera un puntero, un receptor de valores es eficiente y claro".

El primer punto dice que es "muy barato", pero la pregunta es más si es más barato que el receptor de puntero. Así que hice un pequeño punto de referencia (código en esencia) que me mostró que el receptor de puntero es más rápido incluso para una estructura que tiene solo un campo de cadena. Estos son los resultados:

// Struct one empty string property
BenchmarkChangePointerReceiver  2000000000               0.36 ns/op
BenchmarkChangeItValueReceiver  500000000                3.62 ns/op


// Struct one zero int property
BenchmarkChangePointerReceiver  2000000000               0.36 ns/op
BenchmarkChangeItValueReceiver  2000000000               0.36 ns/op

(Editar: tenga en cuenta que el segundo punto dejó de ser válido en las versiones más recientes de Go, consulte los comentarios) .
Segundo punto dice, es "eficiente y claro" lo que es más una cuestión de gustos, ¿no? Personalmente, prefiero la coherencia al usarlo en todas partes de la misma manera. ¿Eficiencia en qué sentido? En cuanto al rendimiento, parece que los punteros son casi siempre más eficientes. Pocas pruebas con una propiedad int mostraron una ventaja mínima del receptor Value (rango de 0.01-0.1 ns / op)

¿Alguien puede decirme un caso en el que un receptor de valores claramente tenga más sentido que un receptor de puntero? ¿O estoy haciendo algo mal en el punto de referencia? ¿Pasé por alto otros factores?

Tenga en cuenta que las preguntas frecuentes mencionan la coherencia

Lo siguiente es la coherencia. Si algunos de los métodos del tipo deben tener receptores de puntero, el resto también debería hacerlo, por lo que el conjunto de métodos es coherente independientemente de cómo se utilice el tipo. Consulte la sección sobre conjuntos de métodos para obtener más detalles.

Como se menciona en este hilo :

La regla sobre punteros frente a valores para receptores es que los métodos de valor se pueden invocar en punteros y valores, pero los métodos de puntero solo se pueden invocar en punteros

Ahora:

¿Alguien puede decirme un caso en el que un receptor de valores claramente tenga más sentido que un receptor de puntero?

El comentario de Revisión de código puede ayudar:

• Si el receptor es un mapa, func o chan, no use un puntero hacia él.
• Si el receptor es un segmento y el método no vuelve a dividir o reasignar el segmento, no utilice un puntero.
• Si el método necesita mutar el receptor, el receptor debe ser un puntero.
• Si el receptor es una estructura que contiene un sync.Mutexcampo de sincronización o similar, el receptor debe ser un puntero para evitar la copia.
• Si el receptor es una estructura o matriz grande, un receptor de puntero es más eficiente. ¿Qué tan grande es? Suponga que es equivalente a pasar todos sus elementos como argumentos al método. Si se siente demasiado grande, también es demasiado grande para el receptor.
• ¿Pueden la función o los métodos, al mismo tiempo o cuando se llaman desde este método, mutar el receptor? Un tipo de valor crea una copia del receptor cuando se invoca el método, por lo que las actualizaciones externas no se aplicarán a este receptor. Si los cambios deben ser visibles en el receptor original, el receptor debe ser un puntero.
• Si el receptor es una estructura, matriz o segmento y cualquiera de sus elementos es un puntero a algo que podría estar mutando, prefiera un receptor de puntero, ya que hará que la intención sea más clara para el lector.
• Si el receptor es una pequeña matriz o estructura que es naturalmente un tipo de valor (por ejemplo, algo como el time.Timetipo), sin campos mutables ni punteros, o es simplemente un tipo básico simple como int o string, un receptor de valor hace sentido .
  Un receptor de valor puede reducir la cantidad de basura que se puede generar; si se pasa un valor a un método de valor, se puede usar una copia en la pila en lugar de asignar en el montón. (El compilador intenta ser inteligente al evitar esta asignación, pero no siempre puede tener éxito). No elija un tipo de receptor de valor por esta razón sin crear un perfil primero.
• Finalmente, en caso de duda, utilice un receptor de puntero.

La parte en negrita se encuentra, por ejemplo, en net/http/server.go#Write():

// Write writes the headers described in h to w.
//
// This method has a value receiver, despite the somewhat large size
// of h, because it prevents an allocation. The escape analysis isn't
// smart enough to realize this function doesn't mutate h.
func (h extraHeader) Write(w *bufio.Writer) {
...
}

Para agregar adicionalmente a @VonC, una gran respuesta informativa.

Me sorprende que nadie haya mencionado realmente el costo de mantenimiento una vez que el proyecto crece, los desarrolladores antiguos se van y llega uno nuevo. Go seguramente es un idioma joven.

En general, trato de evitar los consejos cuando puedo, pero tienen su lugar y su belleza.

Uso punteros cuando:

• trabajar con grandes conjuntos de datos
• tener un estado de mantenimiento de estructura, por ejemplo, TokenCache,
• • Me aseguro de que TODOS los campos sean PRIVADOS, la interacción solo es posible a través de receptores de métodos definidos
• • No paso esta función a ninguna goroutine

P.ej:

type TokenCache struct {
    cache map[string]map[string]bool
}

func (c *TokenCache) Add(contract string, token string, authorized bool) {
    tokens := c.cache[contract]
    if tokens == nil {
        tokens = make(map[string]bool)
    }

    tokens[token] = authorized
    c.cache[contract] = tokens
}

Razones por las que evito los consejos:

• los punteros no son simultáneamente seguros (el objetivo de GoLang)
• una vez receptor de puntero, siempre receptor de puntero (para todos los métodos de Struct para la coherencia)
• los mutex son seguramente más caros, más lentos y más difíciles de mantener en comparación con el "costo de copia de valor"
• hablando de "costo de copia de valor", ¿es eso realmente un problema? La optimización prematura es la raíz de todos los males, siempre puede agregar punteros más tarde
• me obliga de forma directa y consciente a diseñar pequeñas estructuras
• Los punteros se pueden evitar principalmente diseñando funciones puras con una intención clara y una E / S obvia.
• la recolección de basura es más difícil con los punteros, creo
• más fácil de discutir sobre encapsulación, responsabilidades
• manténgalo simple, estúpido (sí, los punteros pueden ser complicados porque nunca se sabe el desarrollador del próximo proyecto)
• La prueba unitaria es como caminar por un jardín rosa (¿expresión única en eslovaco?), significa fácil
• no NIL if condiciones (NIL se puede pasar donde se esperaba un puntero)

Mi regla general es escribir tantos métodos encapsulados como sea posible, como:

package rsa

// EncryptPKCS1v15 encrypts the given message with RSA and the padding scheme from PKCS#1 v1.5.
func EncryptPKCS1v15(rand io.Reader, pub *PublicKey, msg []byte) ([]byte, error) {
    return []byte("secret text"), nil
}

cipherText, err := rsa.EncryptPKCS1v15(rand, pub, keyBlock) 

ACTUALIZAR:

Esta pregunta me inspiró a investigar más el tema y escribir una publicación de blog al respecto https://medium.com/gophersland/gopher-vs-object-oriented-golang-4fa62b88c701