Digamos que tengo una estructura con el estado, y algunas funciones de miembro del mencionado estructura. Digamos que el miembro de estructura devuelve una instancia de su propio tipo, y me llaman a funciones adicionales en esa instancia, y pasan el resultado de llamar a algún otro miembro en la instancia inicial como argumento. Es del orden de invocación entre la primera invocación, y la invocación argumento, garantizada?
(Este patrón aparece mucho cuando se trata de construir constructor de objetos de tipo que tienen algún estado interno, como una pila de expresión.)
package main
import (
fmt
)
type q struct {
val int
}
func (s *q) getVal() int {
return s.val
}
func (s *q) a() *q {
s.val += 1
return s
}
func (s *q) b(i int) int {
return i + s.val
}
func main() {
s := &q{}
// this currently prints 2
// but is that guaranteed?
fmt.Println(s.a().b(s.getVal()))
}
En concreto, es el orden de invocación relativa de s.a()frente s.getVal()garantizado? Golang define la orden léxico de izquierda a derecha, pero sólo por una expresión individual, y s.a().b()parece que es técnicamente una expresión diferente a s.getVal().
El comportamiento que tiene actualmente es el comportamiento que me gustaría y espero, pero no puedo decir si es también un comportamiento que puedo confiar en para siempre.
